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)); }