public void Publish(Event @event)
{
if (!_connection.IsConnected)
{
_connection.TryConnect();
}
using var channel = _connection.CreateModel();
var eventName = @event.GetType()
.Name;
channel.ExchangeDeclare(BrokerName,
"direct");
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
Policies.WaitRetryPolicy(3).Execute(() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2;
channel.BasicPublish(BrokerName,
eventName,
true,
properties,
body);
});
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
//Define the que
channel.QueueDeclare(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, eventArgs) =>
{
Console.WriteLine("Sender RabbitMQ");
};
channel.ConfirmSelect();
}
}
public Task Publish <TEvent>(TEvent @event, string exchange, CancellationToken cancellationToken) where TEvent : IEvent
{
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetry(_options.PublishRetryCount,
retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, _) =>
{
_logger.LogWarning(ex.ToString());
});
_connection.VerifyConnection();
exchange ??= _options.PublishExchange ?? _options.Exchanges.FirstOrDefault();
var channel = _connection.CreateModel();
channel.ExchangeDeclare(exchange: exchange, type: "direct");
var message = JsonSerializer.Serialize(@event);
var body = Encoding.UTF8.GetBytes(message);
var eventName = @event.GetType().Name;
policy.Execute(() =>
{
channel.BasicPublish(exchange, eventName, null, body);
});
return(Task.CompletedTask);
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
// durable: false -> dar memory , true -> dar database
// exclusive: permission mide baraye estefade be baghie connectionha
channel.QueueDeclare(queueName, durable: false, exclusive: false, autoDelete: false); // elam mikone ke ye queue hast
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties(); // properties haro sakhtan
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect(); // tayidie publisher
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties, body: body); // ye message ro publish mikone
channel.WaitForConfirmsOrDie(); // vaymise ta tayidie migire ke hameye message ha publish shode
channel.BasicAcks += (sender, eventArgs) =>
{
Console.WriteLine("Sent to rabbit mq."); // vaqti ye acks az broker miad samte ma in call mishe baraye tayidie
};
channel.ConfirmSelect();
}
}
public void PublishSaveDiaryNoteEvent(string queueName, SaveDiaryNoteEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
channel.QueueDeclare(queueName, durable: false, exclusive: false, autoDelete: false, arguments: null);
var message = JsonConvert.SerializeObject(publishModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties prop = channel.CreateBasicProperties();
prop.Persistent = true;
prop.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "",
routingKey: queueName,
basicProperties: null,
body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArgs) => {
Console.WriteLine("Sent RabbitMq");
};
channel.ConfirmSelect();
}
}
private IModel CreateNewChannel(string exchangeName)
{
if (!_connection.IsConnected)
{
_connection.TryConnect();
}
return(_connection.CreateModel(exchangeName));
}
private void SubsManager_OnEventRemoved(object sender, string eventName)
{
if (!_connection.IsConnected)
{
_connection.TryConnect();
}
using (var channel = _connection.CreateModel())
{
channel.QueueUnbind(_queueName, _brokerName, eventName);
if (!SubscriptionManager.IsEmpty)
{
return;
}
_queueName = string.Empty;
_consumerChannel?.Close();
}
}
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);
consumer.Received += RecievedEvent;
channel.BasicConsume(queue: EventBusConstants.BasketCheckoutQueue, autoAck: true, consumer: consumer, noLocal: false, exclusive: false, arguments: null);
}
public async Task StartAsync(CancellationToken cancellationToken)
{
await _connection.TryConnect();
if (!_connection.IsConnected)
{
throw new InvalidOperationException("Could not connect to RabbitMQ");
}
// var eventName = typeof(T).Name;
// Console.WriteLine($"Event Name: {eventName}");
_channel = _connection.CreateModel();
_channel.ExchangeDeclare(exchange: RabbitMqEventBus.EXAMPLE_EXCHANGE_NAME, type: "direct");
_channel.QueueDeclare(queue: _queueName,
durable: true,
exclusive: false,
autoDelete: false,
arguments: null);
var consumer = new EventingBasicConsumer(_channel);
consumer.Received += async(model, ea) => {
var eventName = ea.RoutingKey;
var message = Encoding.UTF8.GetString(ea.Body);
Console.WriteLine($" [x] Received {message}, {eventName}");
T convertedMessage = JsonConvert.DeserializeObject <T>(message);
_eventHandler.Handle(convertedMessage);
_channel.BasicAck(ea.DeliveryTag, multiple: false);
};
_channel.BasicConsume(queue: _queueName,
autoAck: false,
consumer: consumer);
//_channel.QueueDeclare(queue: _queueName, // "hello",
// durable: false,
// exclusive: false,
// autoDelete: false,
// arguments: null);
//var consumer = new EventingBasicConsumer(_channel);
//consumer.Received += (model, ea) => {
// var body = ea.Body;
// var message = Encoding.UTF8.GetString(body);
// Console.WriteLine(" [x] Received {0}", message);
// T convertedMessage = JsonConvert.DeserializeObject<T>(message);
// _eventHandler.Handle(convertedMessage);
//};
//_channel.BasicConsume(queue: _queueName, // "hello",
// autoAck: true,
// consumer: consumer);
}
private IModel CreateChannel()
{
_rabbitMqConnection.TryConnection();
var channel = _rabbitMqConnection.CreateModel();
channel.ExchangeDeclare(exchange: _exchangeName, type: ExchangeType.Direct);
channel.QueueDeclare(_routingKey, true, false, false, null);
channel.QueueBind(_routingKey, _exchangeName, _routingKey, null);
return(channel);
}
public void Consume()
{
var channel = _connection.CreateModel();
channel.QueueDeclare(queue: EventBusEnum.BASKET_CHECKOUT_QUEUE.ToString(), durable: false, false, false,
null);
var con = new EventingBasicConsumer(channel);
con.Received += ReceivedEvent;
channel.BasicConsume(queue: EventBusEnum.BASKET_CHECKOUT_QUEUE.ToString(), autoAck: true, consumer: con,
noLocal: false, exclusive: false, arguments: null);
}
//Main Method.
public void Consume()
{
var channel = _connection.CreateModel();
channel.QueueDeclare(queue: EventBusConstans.BasketCheckOutQueue, durable: false, exclusive: false, autoDelete: false, arguments: null);
var consumer = new EventingBasicConsumer(channel);
consumer.Received += ReceivedEvent;
//que with given name will be consumed and above event will be fired.
channel.BasicConsume(queue: EventBusConstans.BasketCheckOutQueue, autoAck: true, consumer: consumer);
}
/**
* Event used for microservices
* CLASS 59
*/
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent publishModel)
{
using (var channel = _connection.CreateModel())
{
// Durable :
// TRUE: that means you would like to save this queue with physically memory
// FALSE: store data in memory
// Exclusive
// It is giving you permission to use of its other connection
// false: we don't need to use and this queue with other connections
// AutoDelete:
// Its determined to automate deletion or not
// Arguments
// is parameters related with determined to exchange, if you have any additional args with these queue and exchange
channel.QueueDeclare(queue: queueName, durable: false, exclusive: false, autoDelete: false,
arguments: null);
// before use JsonConvert.SerializeObject install Newtonsoft.Json
var message = JsonConvert.SerializeObject(publishModel);
// converting the byte format our published model basketCheckoutEvent
var body = Encoding.UTF8.GetBytes(message);
//=====================================================================================================
// for more information about this params, check RabbitMQ documentation
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
//====================================================================================================
//properties: we give the basic properties, body also define it in here
// queueName: is mandatory
// BasicPublish(): allow to message to be received and sent to queue
// It is using the root algorithm
// exchange: direct - fanout - topic
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName, mandatory: true, basicProperties: properties,
body: body);
channel.WaitForConfirmsOrDie();
//====================================================================================================
//A C K definition
// these operation provide to create a queue inside the rabbitMQ
// REVIEW MORE IN RABBITMQ DOC
channel.BasicAcks += (sender, eventArgs) => { Console.WriteLine("SENT_____R A B B I T MQ"); };
channel.ConfirmSelect();
}
}
public void PublishBasketCheckout(string queueName, BasketCheckoutEvent basketModel)
{
using (var channel = _connection.CreateModel())
{
channel.QueueDeclare(queueName, false, false, false, null);
var message = JsonConvert.SerializeObject(basketModel);
var body = Encoding.UTF8.GetBytes(message);
IBasicProperties properties = channel.CreateBasicProperties();
properties.Persistent = true;
properties.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish("", queueName, properties, body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, eventArg) =>
{
Console.WriteLine("send RabbitMq");
};
channel.ConfirmSelect();
}
}
public async Task PublishAsync(string routingKey, object model)
{
if (!_rabbitMqConnection.IsConnected)
{
_rabbitMqConnection.TryConnect();
}
var policy = Policy.Handle <BrokerUnreachableException>()
.Or <SocketException>()
.WaitAndRetryAsync(_retryCount, retryAttempt => TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)), (ex, time) =>
{
_logger.LogWarning(ex.ToString());
});
using (var channel = _rabbitMqConnection.CreateModel())
{
channel.ExchangeDeclare(exchange: BROKER_NAME, type: "direct");
var message = JsonConvert.SerializeObject(model);
var body = Encoding.UTF8.GetBytes(message);
await policy.ExecuteAsync(async() =>
{
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2; //持久化
channel.BasicPublish(
exchange: BROKER_NAME,
routingKey: routingKey,
mandatory: true,
basicProperties: properties,
body: body);
//return Task.CompletedTask;
});
}
}
public void EnqueueEvent <TEvent>(Event <TEvent> @event) where TEvent : Event <TEvent>
{
if (_connection.IsConnected is false)
{
_connection.TryConnect();
}
using var channel = _connection.CreateModel();
var eventName = @event.GetType().Name;
channel.ExchangeDeclare(_exchangeName, _exchangeType);
var message = JsonConvert.SerializeObject(@event);
var body = Encoding.UTF8.GetBytes(message);
var properties = channel.CreateBasicProperties();
properties.DeliveryMode = 2;
properties.CorrelationId = @event.MicroServiceId;
try
{
_logger.LogInformation("Publishing in queue: {event}", @event);
channel.BasicPublish(_exchangeName,
eventName,
true,
properties,
body);
}
catch (Exception ex)
{
_logger.LogInformation(ex, "Error publishing in queue: {event}", @event);
}
}
public void PublishBasketCheckout(EventBusEnum queueName, BasketCheckoutEvent publishModel)
{
using var channel = _mqConnection.CreateModel();
channel.QueueDeclare(queueName.ToString(), durable: false, exclusive: false, autoDelete: false, arguments: null);
var message = JsonSerializer.Serialize(publishModel);
var body = Encoding.UTF8.GetBytes(message);
var bp = channel.CreateBasicProperties();
bp.Persistent = true;
bp.DeliveryMode = 2;
channel.ConfirmSelect();
channel.BasicPublish(exchange: "", routingKey: queueName.ToString(), mandatory: true, basicProperties: bp, body: body);
channel.WaitForConfirmsOrDie();
channel.BasicAcks += (sender, args) => { Console.WriteLine($"sent rabbit MQ {publishModel}"); };
channel.ConfirmSelect();
}
public void Consume()
{
var channel = _rabbitMqConnection.CreateModel();
var consumer = new EventingBasicConsumer(channel);
consumer.Received += (ch, ea) =>
{
var body = ea.Body.ToArray();
// copy or deserialise the payload
// and process the message
// ...
channel.BasicAck(ea.DeliveryTag, false);
};
// this consumer tag identifies the subscription
// when it has to be cancelled
String consumerTag = channel.BasicConsume("test", false, consumer);
}
private IModel CreateConsumerChannel()
{
_connection.VerifyConnection();
var channel = _connection.CreateModel();
foreach (var exchange in _exchanges)
{
channel.ExchangeDeclare(exchange: exchange, type: "direct");
}
channel.QueueDeclare(queue: _queueName, durable: true, exclusive: false, autoDelete: false, arguments: null);
channel.CallbackException += (sender, ea) =>
{
_consumerChannel.Dispose();
_consumerChannel = CreateConsumerChannel();
};
return(channel);
}
public RabbitMqBusSubscriber(IRabbitMqConnection connection, IEventProcessor eventProcessor, IOptions <RabbitMqOption> optionWrap)
{
var option = optionWrap.Value;
_queueName = option.Client;
_exchanges = option.Exchanges ?? new string[0];
_connection = connection;
_eventProcessor = eventProcessor;
_eventProcessor.Setup(eventName =>
{
using var channel = _connection.CreateModel();
foreach (var exchange in _exchanges)
{
channel.QueueBind(queue: _queueName, exchange: exchange, routingKey: eventName);
}
});
}
public void Consume()
{
Console.WriteLine("Consume is started");
using var channel = _connection.CreateModel();
// durable: false -> dar memory , true -> dar database
// exclusive: permission mide baraye estefade be baghie connectionha
// vaqti ma darim declare mikonim, yani mikhaym in queue ro bekhunim
channel.QueueDeclare(queue: EventBusConstant.BasketCheckoutQueue, durable: false, exclusive: false, autoDelete: false, null); // elam mikone ke ye queue hast
var consumer = new EventingBasicConsumer(channel);
// inja darim attach mikonim in event ro vaqti recived etefagh biofte chi beshe
consumer.Received += ReceivedEvent;
channel.BasicConsume(queue: EventBusConstant.BasketCheckoutQueue, autoAck: true, consumer: consumer);
Console.WriteLine("Press [enter] to exit.");
Console.ReadLine();
}
public void Publish(BasketCheckoutEvent basketCheckoutEvent)
{
//TODO channel confirmation etc...
string json = JsonConvert.SerializeObject(basketCheckoutEvent);
var body = Encoding.UTF8.GetBytes(json);
var channel = _rabbitMqConnection.CreateModel();
channel.QueueDeclare(queue: "test",
durable: false,
exclusive: false,
autoDelete: false,
arguments: null);
channel.BasicPublish(exchange: "",
routingKey: "test",
basicProperties: null,
body: body);
}
public async Task Publish(string queueName, RabbitMqEvent rabbitMqEvent)
{
if (!_rabbitMqConnection.IsConnected)
{
await this._rabbitMqConnection.TryConnect();
}
string message = JsonConvert.SerializeObject(rabbitMqEvent);
var body = Encoding.UTF8.GetBytes(message);
using (var channel = _rabbitMqConnection.CreateModel()) {
string eventName = rabbitMqEvent.GetType().Name;
channel.ExchangeDeclare(exchange: EXAMPLE_EXCHANGE_NAME, type: "direct");
var channelProps = channel.CreateBasicProperties();
channelProps.DeliveryMode = 2; // Persistent (stored to disk)
channel.BasicPublish(exchange: EXAMPLE_EXCHANGE_NAME,
routingKey: eventName,
mandatory: true,
basicProperties: channelProps,
body: body);
//channel.QueueDeclare(queue: queueName,
// durable: false,
// exclusive: false,
// autoDelete: false,
// arguments: null);
//string message = JsonConvert.SerializeObject(rabbitMqEvent);
//var body = Encoding.UTF8.GetBytes(message);
//channel.BasicPublish(exchange: "",
// routingKey: queueName,
// basicProperties: null,
// body: body);
Console.WriteLine($" [x] Sent {message}, {eventName}, {queueName}");
}
}
