public void Consume() { var channel = _connection.CreateModel(); channel.QueueDeclare(queue: EventBusConstant.BasketChekoutQueue, durable: false, exclusive: false, autoDelete: false, arguments: null); var consumer = new EventingBasicConsumer(channel); consumer.Received += ReceivedEvent; channel.BasicConsume(queue: EventBusConstant.BasketChekoutQueue, autoAck: true, consumer: consumer, noLocal: false, exclusive: false, arguments: null); }
public void Consume() { var channel = _connection.CreateModel(); channel.QueueDeclare(EventBusConstans.BasketCheckoutQueue, false, false, false, null); var consumer = new EventingBasicConsumer(channel); consumer.Received += RecievedEvent; channel.BasicConsume(EventBusConstans.BasketCheckoutQueue, true, consumer); }
//public EventBusRabbitMQConsumer(IRabbitMQConnection connection, IMediator mediator, IMapper mapper) //{ // _connection = connection ?? throw new ArgumentNullException(nameof(connection)); // _mediator = mediator ?? throw new ArgumentNullException(nameof(mediator)); // _mapper = mapper ?? throw new ArgumentNullException(nameof(mapper)); //} public void Consume() { var channel = _connection.CreateModel(); channel.QueueDeclare(queue: EventBusConstants.UpdateIssueInSprintQueue, durable: false, exclusive: false, autoDelete: false, arguments: null); var consumer = new EventingBasicConsumer(channel); //Create event when something receive consumer.Received += ReceivedEvent; channel.BasicConsume(queue: EventBusConstants.UpdateIssueInSprintQueue, autoAck: true, consumer: consumer); }
public void Consume() { var channel = _connection.CreateModel(); channel.QueueDeclare("test", false, false, false, null); var consumer = new EventingBasicConsumer(channel); channel.QueueDeclare(EventBusConsts.SendEmailQueque, false, false, false, null); channel.BasicConsume(queue: EventBusConsts.SendEmailQueque, autoAck: true, consumer: consumer); consumer.Received += ReceivedEvent; // channel.BasicConsume(EventBusConsts.SendEmailQueque, true, consumer); }
/// <summary/> public void Publish(RabbitMQEvent @event) { if (!CanConnect) { return; } OpenRabbitMQConnectionIfItIsNotOpened(); var policy = Policy.Handle <BrokerUnreachableException>().Or <SocketException>() .WaitAndRetry(_connection.RetryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) => { _logger.LogWarning(ex, "Could not publish event: {EventId} after {Timeout}s ({ExceptionMessage})", @event.Id, $"{time.TotalSeconds:n1}", ex.Message); }); var eventName = @event.GetType().Name; _logger.LogTrace("Creating RabbitMQ channel to publish event: {EventId} ({EventName})", @event.Id, eventName); using var channel = _connection.CreateModel(); channel.ExchangeDeclare(exchange: SingeAplicationName, type: ExchangeType.Direct); var message = JsonConvert.SerializeObject(@event); var messageBody = Encoding.UTF8.GetBytes(message); policy.Execute(() => { var properties = channel.CreateBasicProperties(); properties.DeliveryMode = 2; // persistent channel.BasicPublish( exchange: SingeAplicationName, routingKey: eventName, mandatory: true, basicProperties: properties, body: messageBody); }); }
public void Publish(IEvent @event) { var eventName = @event.GetType().Name; _logger.LogInformation($"Executando { nameof(Publish) }({eventName})"); if (_connection.Disconnected) { _connection.Connect(); } var policy = Policy.Handle <BrokerUnreachableException>() .Or <SocketException>() .WaitAndRetry(3, attemp => TimeSpan.FromSeconds(Math.Pow(2, attemp)), (ex, time) => { _logger.LogWarning("Não foi possível publicar a '{EventName}': ({ExceptionMessage})", eventName, ex.Message); }); using (var channel = _connection.CreateModel()) { DeclareExchange(channel); DeclareQueueAndBind(eventName, channel); policy.Execute(() => { _logger.LogInformation("Publicando '{EventName}': {Event}", eventName, @event.ToJson()); channel.BasicPublish( exchange: EXCHANGE_NAME, routingKey: eventName, basicProperties: null, body: @event.ToJson(IgnoredProperties).ToBytes() ); }); } }
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel) { using (var channel = _connection.CreateModel()) { channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null); var message = JsonConvert.SerializeObject(publishModel); var body = Encoding.UTF8.GetBytes(message); IBasicProperties properties = channel.CreateBasicProperties(); properties.Persistent = true; properties.DeliveryMode = 2; channel.ConfirmSelect(); channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body); channel.WaitForConfirmsOrDie(); channel.BasicAcks += (sender, args) => { Console.WriteLine("Sent RabbitMQ"); }; channel.ConfirmSelect(); } }
public void Consume() { // Open new channel var channel = _connection.CreateModel(); // Read queue channel.QueueDeclare(queue: EventBusConstants.BasketCheckoutQueue, durable: false, exclusive: false, autoDelete: false, arguments: null); var consumer = new EventingBasicConsumer(channel); // Attach main event, get RabbitMQ message consumer.Received += ReceivedEvent; channel.BasicConsume(queue: EventBusConstants.BasketCheckoutQueue, autoAck: true, consumer: consumer); }
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent checkoutEvent) { using IModel channel = connection.CreateModel(); channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null); string message = JsonConvert.SerializeObject(checkoutEvent); byte[] body = Encoding.UTF8.GetBytes(message); IBasicProperties properties = channel.CreateBasicProperties(); properties.Persistent = true; properties.DeliveryMode = 2; channel.ConfirmSelect(); channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body); channel.WaitForConfirmsOrDie(); channel.BasicAcks += (sender, ebentArgs) => { Console.WriteLine("Sent RabitMQ"); //implement acks handle }; channel.ConfirmSelect(); //using (IModel channel = connection.CreateModel()) //{ // channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null); // string message = JsonConvert.SerializeObject(checkoutEvent); // byte[] body = Encoding.UTF8.GetBytes(message); // IBasicProperties properties = channel.CreateBasicProperties(); // properties.Persistent = true; // properties.DeliveryMode = 2; // channel.ConfirmSelect(); // channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body); // channel.WaitForConfirmsOrDie(); // channel.BasicAcks += (sender, ebentArgs) => // { // Console.WriteLine("Sent RabitMQ"); // //implement acks handle // }; // channel.ConfirmSelect(); //} }
public RpcClient(IRabbitMQConnection connection) { _connection = connection; channel = connection.CreateModel(); replyQueueName = channel.QueueDeclare().QueueName; consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { if (!callbackMapper.TryRemove(ea.BasicProperties.CorrelationId, out TaskCompletionSource <string> tcs)) { return; } var body = ea.Body.ToArray(); var response = Encoding.UTF8.GetString(body); tcs.TrySetResult(response); }; }
private IModel CreateConsumerChannel() { if (!_connection.IsConnected) { _connection.TryConnect(); } var channel = _connection.CreateModel(); channel.QueueDeclare( queue: _queueName, durable: true, exclusive: false, autoDelete: false, arguments: null); return(channel); }
public void Consume() { var channel = _connection.CreateModel(); channel.QueueDeclare(queue: EventBusConstants.BasketCheckoutQueue, durable: false, exclusive: false, autoDelete: false, arguments: null); var consumer = new EventingBasicConsumer(channel); //Create Event when something received consumer.Received += Consumer_Received; channel.BasicConsume(queue: EventBusConstants.BasketCheckoutQueue, autoAck: true, consumer: consumer); }
public void Consume() { // _logger.LogCDCIError("test log"); using (var channel = _connection.CreateModel()) { channel.QueueDeclare(queue: EventBusConstants.SmsQue, durable: true, exclusive: false, autoDelete: false, arguments: null); channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false); Console.WriteLine(" [*] Waiting for messages."); var consumer = new EventingBasicConsumer(channel); consumer.Received += ReceivedEvent; channel.BasicConsume(queue: EventBusConstants.SmsQue, autoAck: false, consumer: consumer); Console.WriteLine(" Press [enter] to exit."); Console.ReadLine(); } }
public void PublishPrepareReport(string queueName, PrepareReportEvent publishModel) { //create channel to perform the queue operations using (var channel = _connection.CreateModel()) { channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, null); var message = JsonConvert.SerializeObject(publishModel); var body = Encoding.UTF8.GetBytes(message); IBasicProperties properties = channel.CreateBasicProperties(); properties.Persistent = true; properties.DeliveryMode = 2; channel.ConfirmSelect(); channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body); channel.WaitForConfirmsOrDie(); channel.ConfirmSelect(); } }
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel) { using (var channel = _connection.CreateModel()) { channel.QueueDeclare ( queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null ); string serializedMessage = JsonConvert.SerializeObject(publishModel); Console.WriteLine("[EventBusRabbitMQProducer][PublishBasketCheckout] => (serializedMessage): "); Console.WriteLine(serializedMessage); Console.WriteLine(""); byte[] messageByteArray = Encoding.UTF8.GetBytes(serializedMessage); IBasicProperties basicProps = channel.CreateBasicProperties(); basicProps.Persistent = true; basicProps.DeliveryMode = 2; channel.ConfirmSelect(); channel.BasicPublish ( exchange: "", routingKey: queueName, mandatory: true, basicProperties: basicProps, body: messageByteArray ); channel.WaitForConfirmsOrDie(); channel.BasicAcks += (sender, eventArgs) => { Console.WriteLine("[EventBusRabbitMQProducer][PublishBasketCheckout] => (IN 'channel.BasicAcks')"); }; channel.ConfirmSelect(); } }
private IModel CreateChannel(Type @event) { Init(@event); _persistentConnection.TryConnect(); var channel = _persistentConnection.CreateModel(); channel.ExchangeDeclare(exchange: BROKER_NAME, type: ExchangeType.Direct); channel.QueueDeclare(_queueName, true, false, false, null); channel.QueueBind(_queueName, BROKER_NAME, _queueName, null); channel.CallbackException += (sender, ea) => { _consumerChannel.Dispose(); _consumerChannel = CreateChannel(@event); }; return(channel); }
public void Publish <T>(T @event) where T : Event { try { if (!_persistentConnection.IsConnected) { _persistentConnection.TryConnect(); } var policy = RetryPolicy.Handle <BrokerUnreachableException>() .Or <SocketException>() .WaitAndRetry(2, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) => { // _logger.LogWarning(ex, "Could not publish event: {EventId} after {Timeout}s ({ExceptionMessage})", @event.Id, $"{time.TotalSeconds:n1}", ex.Message); }); //var factory = new ConnectionFactory() { HostName = "rabbitmqX", Port = 5672 }; //factory.UserName = "******"; //factory.Password = "******"; //factory.AutomaticRecoveryEnabled = true; //factory.TopologyRecoveryEnabled = true; //factory.NetworkRecoveryInterval = TimeSpan.FromSeconds(5); //factory.UseBackgroundThreadsForIO = true; //factory.RequestedHeartbeat = 2; // using (var connection = factory.CreateConnection()) using (var channel = _persistentConnection.CreateModel()) { policy.Execute(() => { var eventName = @event.GetType().Name; channel.QueueDeclare(eventName, false, false, false, null); var message = JsonConvert.SerializeObject(@event); byte[] body = Encoding.UTF8.GetBytes(message); channel.BasicPublish("", eventName, null, body); } ); } Console.WriteLine("publish"); } catch (Exception ex) { Console.WriteLine("Error : " + ex.Message); } }
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel) { using (var channel = _connection.CreateModel()) { channel.QueueDeclare(queueName, false, false, false, null); var message = JsonConvert.SerializeObject(publishModel); var body = Encoding.UTF8.GetBytes(message); var properties = channel.CreateBasicProperties(); properties.Persistent = true; properties.DeliveryMode = 2; channel.ConfirmSelect(); channel.BasicPublish("", queueName, true, properties, body); channel.WaitForConfirmsOrDie(); channel.BasicAcks += (sender, args) => { Console.WriteLine("Sent RabbitMQ"); }; channel.ConfirmSelect(); } }
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent model) { using (var channel = _connection.CreateModel()) { channel.QueueDeclare(queueName, false, false, false, null); var properties = channel.CreateBasicProperties(); properties.Persistent = true; properties.DeliveryMode = 2; // persistent var message = JsonConvert.SerializeObject(model); var body = Encoding.UTF8.GetBytes(message); channel.ConfirmSelect(); channel.BasicPublish("", queueName, true, properties, body); channel.WaitForConfirmsOrDie(); channel.BasicAcks += Channel_BasicAcks; channel.ConfirmSelect(); } }
public void Consume() { var channel = _connection.CreateModel(); channel.QueueDeclare(queue: "rpc_queue", durable: false, exclusive: false, autoDelete: false, arguments: null); channel.BasicQos(0, 1, false); var consumer = new EventingBasicConsumer(channel); channel.BasicConsume(queue: "rpc_queue", autoAck: false, consumer: consumer); consumer.Received += (model, ea) => { string response = null; var body = ea.Body.ToArray(); var props = ea.BasicProperties; var replyProps = channel.CreateBasicProperties(); replyProps.CorrelationId = props.CorrelationId; try { var message = Encoding.UTF8.GetString(body); int id = int.Parse(message); ServiceResponse <Enums.UserType> res = _accountService.GetUserType(id); response = JsonSerializer.Serialize(res); } catch (Exception e) { Console.WriteLine("Error at RPC Server: " + e.Message); response = ""; } finally { var responseBytes = Encoding.UTF8.GetBytes(response); channel.BasicPublish(exchange: "", routingKey: props.ReplyTo, basicProperties: replyProps, body: responseBytes); channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false); } }; }
public RabbitMQEventPublisher( IRabbitMQConnection connection, ILogger <RabbitMQEventPublisher> logger, string exchangeName, string queueName = null) { _connection = connection ?? throw new ArgumentNullException(nameof(connection)); _logger = logger ?? throw new ArgumentNullException(nameof(logger)); _exchangeName = exchangeName; if (!_connection.IsConnected) { _connection.TryConnect(); } using var channel = _connection.CreateModel(); // create exchange channel.ExchangeDeclare( exchange: _exchangeName, type: "topic"); // create queue and bind to exchange if necessary if (!string.IsNullOrWhiteSpace(queueName)) { channel.QueueDeclare( queue: queueName, durable: true, exclusive: false, autoDelete: false, arguments: null); channel.QueueBind( queue: queueName, exchange: exchangeName, routingKey: "#", arguments: null ); } }
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel) { using (var channel = _connection.CreateModel()) { channel.QueueDeclare( queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: null ); var message = JsonConvert.SerializeObject(publishModel); var body = Encoding.UTF8.GetBytes(message); IBasicProperties properties = channel.CreateBasicProperties(); properties.Persistent = true; properties.DeliveryMode = 2; // https://rabbitmq.com/tutorials/amqp-concepts.html channel.ConfirmSelect(); channel.BasicPublish( exchange: "", // Direct exchg (empty str == amq.direct) routingKey: queueName, mandatory: true, basicProperties: properties, body: body ); channel.WaitForConfirmsOrDie(); channel.BasicAcks += (sender, EventArgs) => { Console.WriteLine("Sent msg acknowledge to RabbitMQ"); //implement ack handle }; channel.ConfirmSelect(); } }
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent checkoutEvent) { using (var channel = _connection.CreateModel()) { channel.QueueDeclare(queueName, false, false, false, null); channel.ConfirmSelect(); var props = channel.CreateBasicProperties(); props.Persistent = true; props.DeliveryMode = 2; channel.BasicAcks += (sender, eventArgs) => { Console.WriteLine("Basket Checkout Event has been Published Successfully !"); }; channel.BasicPublish("", queueName, true, props, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(checkoutEvent))); channel.WaitForConfirmsOrDie(); channel.ConfirmSelect(); } }
public void Publish <T>(string queueName, T publishModel) where T : class { using (var channel = _connection.CreateModel()) { channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false, arguments: default);