public async Task SendIntegrationEvent(IIntegrationEvent evento)
{
var sender = _senders.SingleOrDefault(x => x.EntityPath == evento.GetType().Name);
if (sender == null)
{
throw new NotImplementedException(
$"No hay un sender implementado para la cola {evento.GetType().Name}");
}
string jsonString = JsonSerializer.Serialize(evento, evento.GetType());
byte[] objBytes = Encoding.UTF8.GetBytes(jsonString);
ServiceBusMessage message = new ServiceBusMessage(new BinaryData(objBytes))
{
ContentType = "application/json"
};
if (evento is ISessionIntegrationEvent sessionEvent)
{
if (string.IsNullOrEmpty(sessionEvent.IdSessionId))
{
throw new InvalidOperationException(
$"Si el evento herada {nameof(ISessionIntegrationEvent)} es necesario especificar la session, si no dese sesiones use {nameof(IIntegrationEvent)}");
}
message.SessionId = sessionEvent.IdSessionId;
}
await sender.SendMessageAsync(message);
}
/// <inheritdoc />
public void Publish(IIntegrationEvent @event)
{
if (!_persistentConnection.IsConnected)
{
_persistentConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
_logger.LogWarning(ex.ToString());
});
using (var channel = _persistentConnection.CreateModel())
{
var eventName = @event.GetType().Name;
channel.ExchangeDeclare(exchange: _brokerName, type: "direct");
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
policy.Execute(() =>
{
channel.BasicPublish(exchange: _brokerName, routingKey: eventName, basicProperties: null, body: body);
});
}
}
public override async ValueTask Publish(IIntegrationEvent @event)
{
if (!PersistentConnection.IsConnected)
{
PersistentConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.Or <Exception>()
.WaitAndRetryForever(retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
Logger.LogWarning(ex.ToString());
});
using var channel = PersistentConnection.CreateModel();
var routingKey = @event.RoutingKey;
channel.ExchangeDeclare(ExchangeDeclareParameters.ExchangeName, ExchangeDeclareParameters.ExchangeType, ExchangeDeclareParameters.ExchangeDurable, ExchangeDeclareParameters.ExchangeAutoDelete);
await using var ms = new MemoryStream();
Serializer.Serialize(ms, @event);
var body = ms.ToArray();
policy.Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 1; //2 = persistent, write on disk
properties.CorrelationId = _correlationId;
properties.ReplyTo = _queueNameReply;
channel.BasicPublish(ExchangeDeclareParameters.ExchangeName, routingKey, true, properties, body);
});
}
public async Task PublishAsync(IIntegrationEvent @event)
{
_logger.LogTrace($"Publishing message of type {{{@event.GetType().Name}}}.");
await _client.PublishAsync(@event);
_logger.LogTrace($"Successfully published message of type {{{@event.GetType().Name}}}.");
}
private static async Task SendIntegrationEventsAsync(IEnumerable <Func <IIntegrationEvent, CancellationToken, Task> > allHandlers,
IIntegrationEvent integrationEvent, CancellationToken cancellationToken)
{
foreach (var handler in allHandlers)
{
await handler(integrationEvent, cancellationToken).ConfigureAwait(false);
}
}
private DynamicTableEntity Serialize(IIntegrationEvent integrationEvent, bool isPublished)
{
return(new DynamicTableEntity(integrationEvent.AggregateRootId, GetRowKey(integrationEvent.Created))
{
Properties = AzureTableSerializer.Serialize(integrationEvent, persistType: true),
[IsPublishedColumnName] = new EntityProperty(isPublished)
});
}
public void Publish(IIntegrationEvent integrationEvent)
{
using IModel channel = connection.CreateModel();
channel.ExchangeDeclare(exchange: brokerName, type: ExchangeType.Direct);
channel.BasicPublish(exchange: brokerName, routingKey: integrationEvent.GetType().Name, basicProperties: null, body: Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(integrationEvent)));
}
public IntegrationEventLogEntry DeserializeJsonContent(Type type)
{
// TODO: Use System.Text.Json when it has matured
// The System.Text.Json workaround is currently rather cumbersome: https://docs.microsoft.com/en-us/dotnet/standard/serialization/system-text-json-migrate-from-newtonsoft-how-to#deserialize-to-immutable-classes-and-structs
IntegrationEvent = JsonConvert.DeserializeObject(Content, type) as IIntegrationEvent;
EventType = type;
return(this);
}
public void Publish(IIntegrationEvent @event, string exchangeName)
{
CreateExchange(exchangeName);
var jsonEvent = JsonConvert.SerializeObject(@event);
var encodedEvent = Encoding.UTF8.GetBytes(jsonEvent);
Channel.BasicPublish(exchangeName, string.Empty, body: encodedEvent);
}
/// <inheritdoc />
public Task MarkAsPublishedAsync(IIntegrationEvent @event)
{
var entity = new DynamicTableEntity(DomainStoreEntity.EntityPartitionKey, GetRowKey(@event.Created), "*", new Dictionary <string, EntityProperty>
{
{ nameof(DomainStoreEntity.IsPublished), new EntityProperty(true) }
});
return(tableProxy.ExecuteAsync(TableOperation.Merge(entity)));
}
public void AddIntegrationEvent(IIntegrationEvent @event)
{
if (@event == null)
{
throw new ArgumentNullException(nameof(@event));
}
_integrationEvents.Add(@event);
}
public void Publish(IIntegrationEvent @event, string exchangeName)
{
CreateExchangeIfNotExist(exchangeName);
var json = JsonConvert.SerializeObject(@event);
var bytes = Encoding.UTF8.GetBytes(json);
Channel.BasicPublish(exchangeName, string.Empty, body: bytes);
}
public void Publish(IIntegrationEvent @event, string exchangeName)
{
CreateExchangeIfNotExists(exchangeName);
string message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
Channel.BasicPublish(exchangeName, string.Empty, body: body);
}
/// <inheritdoc />
public Task MarkAsPublishedAsync(IIntegrationEvent @event)
{
var entity = new DynamicTableEntity(@event.AggregateRootId, GetRowKey(@event.Created), "*", new Dictionary <string, EntityProperty>
{
{ IsPublishedColumnName, new EntityProperty(true) }
});
return(MergeAsync(entity));
}
public override Task HandleAsync(IIntegrationEvent integrationEvent, CancellationToken cancellationToken, ServiceFactory serviceFactory,
Func <IEnumerable <Func <IIntegrationEvent, CancellationToken, Task> >, IIntegrationEvent, CancellationToken, Task> send)
{
var handlers = serviceFactory
.GetInstances <IIntegrationEventHandler <TIntegrationEvent> >()
.Select(x => new Func <IIntegrationEvent, CancellationToken, Task>((theIntegrationEvent, theToken) =>
x.HandleAsync((TIntegrationEvent)theIntegrationEvent, theToken)));
return(send(handlers, integrationEvent, cancellationToken));
}
public IntegrationEventLogEntry(IIntegrationEvent @event, Guid transactionId)
{
EventId = @event.EventId;
TimeStamp = @event.TimeStamp;
EventTypeName = @event.GetType().FullName;
Content = JsonConvert.SerializeObject(@event);
State = EventStateEnum.NotPublished;
TimesSent = 0;
TransactionId = transactionId.ToString();
}
/// <inheritdoc />
public void Publish(IIntegrationEvent integrationEvent)
{
string payload = JsonConvert.SerializeObject(integrationEvent, typeof(IIntegrationEvent), new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
});
byte[] body = Encoding.UTF8.GetBytes(payload);
_channel.BasicPublish(string.Empty, _messageBrokerSettings.QueueName, body: body);
}
public DomainStoreEntity(IIntegrationEvent integrationEvent)
: this()
{
TypeName = integrationEvent.GetType().AssemblyQualifiedName;
PartitionKey = EntityPartitionKey;
RowKey = GetRowKey(integrationEvent.Created);
IsCompressed = true;
var json = JsonConvert.SerializeObject(integrationEvent, TableStorageJsonSerializerSettings.GetDefault());
Data = IsCompressed ? json.Zip() : json;
}
public async Task Publish(string eventName, IIntegrationEvent @event, string replyTo = null, string correlationId = null)
{
if (!string.IsNullOrEmpty(replyTo) && correlationId == null)
{
throw new ArgumentNullException(nameof(correlationId));
}
var json = JsonConvert.SerializeObject(@event, _options.JsonSettings);
var entry = Published.CreateEventLog(@event.Id, eventName, json, correlationId, replyTo);
await _publishedStore.AddAsync(entry);
_pendings = _pendings ?? new List <Published>();
_pendings.Add(entry);
}
private async Task AgregarCola(IIntegrationEvent integrationEvent, CancellationToken cancellationToken)
{
//TODO: ver que s elevante el logueo en caso d eerror
try
{
await _senders.SendIntegrationEvent(integrationEvent);
}
catch (AggregateException ex)
{
throw new SendException(ex.Message, ex.Flatten().InnerException)
{
EventObject = integrationEvent
};
}
}
public virtual async ValueTask Publish(IIntegrationEvent @event)
{
//Logger.LogTrace("Publish: " + @event.GetType());
try
{
if (!PersistentConnection.IsConnected)
{
PersistentConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.Or <Exception>()
.WaitAndRetryForever(retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
Logger.LogWarning(ex.ToString());
});
using var channel = PersistentConnection.CreateModel();
var routingKey = @event.RoutingKey;
channel.ExchangeDeclare(ExchangeDeclareParameters.ExchangeName,
ExchangeDeclareParameters.ExchangeType, ExchangeDeclareParameters.ExchangeDurable,
ExchangeDeclareParameters.ExchangeAutoDelete);
await using var ms = new MemoryStream();
Serializer.Serialize(ms, @event);
var body = ms.ToArray();
policy.Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 1; //2 = persistent, write on disk
channel.BasicPublish(ExchangeDeclareParameters.ExchangeName,
routingKey, true, properties,
body);
});
}
catch (Exception ex)
{
Logger.LogError("EventBusRabbitMq Publish: " + ex.Message + " - " + ex.StackTrace);
if (!(ex.InnerException is null))
{
Logger.LogError("EventBusRabbitMq Publish InnerException: " + ex.InnerException.Message + " - " + ex.InnerException.StackTrace);
}
}
}
/// <summary>
/// Save event to log along with the transaction during which the event was created.
/// </summary>
/// <param name="@event">The integration event to save.</param>
/// <param name="transaction">The transaction during which the event was created.</param>
public Task SaveEventAsync(IIntegrationEvent @event, IDbContextTransaction transaction)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
var eventLogEntry = new IntegrationEventLogEntry(@event, transaction.TransactionId);
// Set the datebase transaction to the provided instance, this ensure integration events
// are logged in the same transaction as the domain data change that spawned the event.
_integrationEventLogContext.Database.UseTransaction(transaction.GetDbTransaction());
_integrationEventLogContext.IntegrationEventLogs.Add(eventLogEntry);
return(_integrationEventLogContext.SaveChangesAsync());
}
public void Publish(IIntegrationEvent @event)
{
//TODO: move "magic strings" to configuration
using (var connection = connectionFactory.CreateConnection())
using (var channel = connection.CreateModel())
{
channel.ExchangeDeclare(exchange: "iss-exchange", type: "direct");
channel.BasicPublish(exchange: "iss-exchange",
routingKey: @event.GetType().Name,
basicProperties: null,
body: PrepareMessage(@event));
}
}
public async Task PublishIntegrationEventAsync(IIntegrationEvent integrationEvent)
{
var eventName = integrationEvent.GetType().Name.Replace(IntegrationEventSuffix, "");
var jsonMessage = JsonConvert.SerializeObject(integrationEvent);
var body = Encoding.UTF8.GetBytes(jsonMessage);
var message = new Message
{
MessageId = Guid.NewGuid().ToString(),
Body = body,
Label = eventName,
CorrelationId = integrationEvent.CorrelationId.ToString()
};
var topicClient = _serviceBusPersisterConnection.CreateTopicClient();
await topicClient.SendAsync(message);
}
/// <inheritdoc />
public void Publish(IIntegrationEvent @event)
{
var eventName = @event.GetType().Name.Replace(IntegrationEventSufix, "");
var jsonMessage = JsonConvert.SerializeObject(@event);
var message = new Message
{
MessageId = new Guid().ToString(),
Body = Encoding.UTF8.GetBytes(jsonMessage),
Label = eventName,
};
var topicClient = _serviceBusPersisterConnection.CreateModel();
topicClient.SendAsync(message)
.GetAwaiter()
.GetResult();
}
/// <inheritdoc />
public Task PrepareAsync(
string transactionId,
IReadOnlyCollection <IAggregateRoot> aggregateRoots,
IIntegrationEvent integrationEvent)
{
var events = aggregateRoots.SelectMany(ar => ar.Events).ToList();
events.Add(integrationEvent);
var entities = events.Select(e => Serialize(transactionId, e)).ToList();
entities.Add(new DynamicTableEntity(transactionId, FlagEntityRowKey, "*", new Dictionary <string, EntityProperty>
{
{ IsCommittedColumnName, new EntityProperty(false) }
}));
return(ExecuteBatchAsync(entities, (e, batch) => batch.Insert(e)));
}
/// <inheritdoc />
public async Task CommitAsync(string transactionId, IIntegrationEvent integrationEvent)
{
// Save side effects to transaction store.
await transactionStore.PrepareAsync(transactionId, aggregates.Values, integrationEvent);
// Save changes in aggregates.
foreach (var aggregate in aggregates.Values)
{
await aggregateStore.UpdatedAsync(aggregate);
}
// Save domain event as not published.
await integrationEventStore.SaveUnpublishedAsync(integrationEvent);
// Mark transaction as commited.
await transactionStore.CommitAsync(transactionId);
// Clean tracked aggregates.
aggregates.Clear();
}
public async Task <TR> CallAsync <TR>(IIntegrationEvent @event, CancellationToken cancellationToken = default)
where TR : IIntegrationEventReply
{
if (!PersistentConnection.IsConnected)
{
PersistentConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.Or <Exception>()
.WaitAndRetryForever(retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
Logger.LogWarning(ex.ToString());
});
using var channel = PersistentConnection.CreateModel();
var routingKey = @event.RoutingKey;
channel.ExchangeDeclare(ExchangeDeclareParameters.ExchangeName, ExchangeDeclareParameters.ExchangeType, ExchangeDeclareParameters.ExchangeDurable, ExchangeDeclareParameters.ExchangeAutoDelete);
await using var ms = new MemoryStream();
Serializer.Serialize(ms, @event);
var body = ms.ToArray();
var correlationId = Guid.NewGuid().ToString();
var tcs = new TaskCompletionSource <dynamic>();
_callbackMapper.TryAdd(correlationId, tcs);
policy.Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 1; //2 = persistent, write on disk
properties.CorrelationId = correlationId;
properties.ReplyTo = QueueName;
channel.BasicPublish(ExchangeDeclareParameters.ExchangeName, routingKey, true, properties, body);
});
cancellationToken.Register(() => _callbackMapper.TryRemove(correlationId, out var tmp));
return(await tcs.Task);
}
public Task SendToAllUnauthorizedClientsAsync(IIntegrationEvent integrationEvent)
{
return(_hubWrapperService.SendToGroupAsync(ConstantVariables.UnauthorizedGroupName, integrationEvent));
}
public Task SendToUserAsync(Guid userId, IIntegrationEvent integrationEvent)
{
return(_hubWrapperService.SendToGroupAsync(userId.ToString(), integrationEvent));
}
