private void StartBasicConsume()
{
_logger.LogTrace("Starting RabbitMQ basic consume");
if (_consumerChannel != null)
{
var consumer = new AsyncEventingBasicConsumer(_consumerChannel);
consumer.Received += Consumer_Received;
_consumerChannel.BasicConsume(
queue: _queueName,
autoAck: false,
consumer: consumer);
}
else
{
_logger.LogError("StartBasicConsume can't call on _consumerChannel == null");
}
}
private void StartBasicConsume <T>() where T : Event
{
var factory = new ConnectionFactory
{
HostName = "localhost",
DispatchConsumersAsync = true
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
var eventName = typeof(T).Name;
channel.QueueDeclare(eventName, false, false, false, null);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += Consumer_Received;
channel.BasicConsume(eventName, true, consumer);
}
private void SetupConnection()
{
var factory = new ConnectionFactory()
{
HostName = hostName,
Port = port,
UserName = username,
Password = password,
DispatchConsumersAsync = true
};
connection = factory.CreateConnection();
model = connection.CreateModel();
model.ExchangeDeclare(exchange, "fanout", durable: true, autoDelete: false);
model.QueueDeclare(queueName, durable: true, autoDelete: false, exclusive: false);
model.QueueBind(queueName, exchange, routingKey);
consumer = new AsyncEventingBasicConsumer(model);
consumer.Received += ConsumerReceived;
consumerTag = model.BasicConsume(queueName, false, consumer);
}
private void StartBasicConsume()
{
logger.LogDebug("Starting RabbitMQ basic consume");
if (consumerChannel != null)
{
var consumer = new AsyncEventingBasicConsumer(consumerChannel);
consumer.Received += ConsumerReceived;
consumerChannel.BasicConsume(
queue: options.QueueName,
autoAck: false,
consumer: consumer);
}
else
{
logger.LogDebug("StartBasicConsume can't call on consumerChannel == null");
}
}
private void StartBasicConsume <T>() where T : Event
{
var factory = new ConnectionFactory()
{
Uri = new Uri("amqp://*****:*****@toad.rmq.cloudamqp.com/cnpjonmv"),
DispatchConsumersAsync = true
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
var eventName = typeof(T).Name;
channel.QueueDeclare(eventName, false, false, false, null);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += Consumer_Received;
channel.BasicConsume(eventName, true, consumer);
}
/// <summary>
/// 设置并开启消费
/// </summary>
private void StartBasicConsume()
{
_logger.LogTrace("Starting RabbitMQ basic consume");
if (_consumerChannel != null)
{
var consumer = new AsyncEventingBasicConsumer(_consumerChannel);
consumer.Received += Consumer_Received;
_consumerChannel.BasicConsume(
queue: _queueName,
autoAck: false,//acknowledge，是否自动确认为已消费。这里设置为false，选择消费后手动回调告诉RabbitMQ已消费
consumer: consumer);
}
else
{
_logger.LogError("StartBasicConsume can't call on _consumerChannel == null");
}
}
public async Task Subscribe <T>() where T : IEvent
{
#region Ok2
var factory = new ConnectionFactory()
{
HostName = "localhost",
DispatchConsumersAsync = true
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
var eventName = typeof(T).Name;
channel.QueueDeclare
(eventName, false, false, false, null);
var consumer = new
AsyncEventingBasicConsumer(channel);
consumer.Received += Consumer_Received;
channel.BasicConsume(eventName, true, consumer);
#endregion
}
protected override void StartBasicConsume()
{
Logger.LogTrace("Starting RabbitMQ basic consume");
if (ConsumerChannel != null)
{
var consumer = new AsyncEventingBasicConsumer(ConsumerChannel);
consumer.Received += ConsumerReceivedAsync;
ConsumerChannel.BasicConsume(
queue: QueueName,
autoAck: false,
consumer: consumer);
}
else
{
Logger.LogError("StartBasicConsume can't call on ConsumerChannel == null");
}
}
private IModel CreateConsumerChannel()
{
if (!_connection.IsConnected)
{
_connection.Connect();
}
var channel = _connection.CreateChannel();
channel.ExchangeDeclare(_connection.Exchange, ExchangeType.Direct, true);
channel.QueueDeclare(_queueName, true, autoDelete: false, exclusive: false);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += OnMessage;
channel.BasicConsume(_queueName, false, consumer);
return(channel);
}
private void Bind(Queue queue)
{
_connection.Model.QueueBind(queue.Name, queue.Exchange, queue.RouteKey);
_logger.LogInformation($"Binded Queue {queue.Name}, Exchange {queue.Exchange} and RouteKey {queue.RouteKey}");
var consumer = new AsyncEventingBasicConsumer(_connection.Model);
consumer.Received += async(sender, eventsArgs) =>
{
try
{
_logger.LogDebug($"A new message was received from {Name} with RoutingKey {eventsArgs.RoutingKey}.");
_logger.LogDebug($"Notifying handlers...");
bool complete = await Notify(eventsArgs.DeliveryTag.ToString(),
eventsArgs.RoutingKey,
eventsArgs.Body,
eventsArgs.BasicProperties.Headers);
if (complete)
{
_connection.Model.BasicAck(eventsArgs.DeliveryTag, multiple: false);
}
//else
//TODO: send to dead letter
_logger.LogDebug($"Message {eventsArgs.DeliveryTag} was Ack...");
}
catch (Exception ex)
{
_connection.Model.BasicNack(eventsArgs.DeliveryTag, multiple: false, requeue: true);
_logger.LogError(ex, $"Message {eventsArgs.DeliveryTag} was Nack...");
throw;
}
};
_connection.Model.BasicConsume(queue.Name, autoAck: false, consumer);
_logger.LogInformation($"Added consumer to Queue {queue.Name}");
}
protected virtual async Task TryCreateChannelAsync()
{
await DisposeChannelAsync();
try
{
Channel = ConnectionPool
.Get(ConnectionName)
.CreateModel();
Channel.ExchangeDeclare(
exchange: Exchange.ExchangeName,
type: Exchange.Type,
durable: Exchange.Durable,
autoDelete: Exchange.AutoDelete,
arguments: Exchange.Arguments
);
Channel.QueueDeclare(
queue: Queue.QueueName,
durable: Queue.Durable,
exclusive: Queue.Exclusive,
autoDelete: Queue.AutoDelete,
arguments: Queue.Arguments
);
var consumer = new AsyncEventingBasicConsumer(Channel);
consumer.Received += HandleIncomingMessageAsync;
Channel.BasicConsume(
queue: Queue.QueueName,
autoAck: false,
consumer: consumer
);
}
catch (Exception ex)
{
Logger.LogException(ex, LogLevel.Warning);
await ExceptionNotifier.NotifyAsync(ex, logLevel : LogLevel.Warning);
}
}
public void Subscribe <T, TH>()
where T : Evento
where TH : IEventHandler <T>
{
var eventName = typeof(T).Name;
var eventType = typeof(TH);
if (!_eventTypes.Contains(typeof(T)))
{
_eventTypes.Add(typeof(T));
}
if (!_handlers.ContainsKey(eventName))
{
_handlers.Add(eventName, new List <Type>());
}
if (_handlers[eventName].Any(x => x.GetType() == eventType))
{
throw new ArgumentException($"Handler { eventType.Name } was registered by { eventName } ");
}
_handlers[eventName].Add(eventType);
var factory = new ConnectionFactory()
{
HostName = "myRabbitServerWeb",
DispatchConsumersAsync = true
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare(eventName, false, false, false, null);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += Consumer_Received;
channel.BasicConsume(eventName, true, consumer);
}
public void Subscribe <T, TH>()
where T : Evento
where TH : IEventoManejador <T>
{
var eventoNombre = typeof(T).Name;
var manejadorEventoTipo = typeof(TH);
if (!_eventoTipos.Contains(typeof(T)))
{
_eventoTipos.Add(typeof(T));
}
if (!_manejadores.ContainsKey(eventoNombre))
{
_manejadores.Add(eventoNombre, new List <Type>());
}
if (_manejadores[eventoNombre].Any(x => x.GetType() == manejadorEventoTipo))
{
throw new ArgumentException($"El manejador {manejadorEventoTipo.Name} fue registrado anteriormente por {eventoNombre}");
}
_manejadores[eventoNombre].Add(manejadorEventoTipo);
var factory = new ConnectionFactory()
{
HostName = "rabbitmq-web-container",
DispatchConsumersAsync = true
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
channel.QueueDeclare(eventoNombre, false, false, false, null);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += Consumer_Delegate;
channel.BasicConsume(eventoNombre, true, consumer);
}
public void Subscribe <THandler, TEvent>(string subscriber, string exchange) where THandler : IEventHandler <TEvent> where TEvent : IEvent
{
BindQueue(exchange, subscriber);
var consumer = new AsyncEventingBasicConsumer(Channel);
consumer.Received += async(o, args) =>
{
using (var scope = _serviceProvider.CreateScope())
{
var handler = scope.ServiceProvider.GetRequiredService <IEventHandler <TEvent> >();
var message = Encoding.UTF8.GetString(args.Body.Span);
var @event = JsonConvert.DeserializeObject <TEvent>(message);
await handler.HandleAsync(@event);
Channel.BasicAck(args.DeliveryTag, multiple: false);
}
};
Channel.BasicConsume(subscriber, autoAck: false, consumer);
}
public Task StartAsync(CancellationToken cancellationToken)
{
var factory = new ConnectionFactory()
{
HostName = rabbitMQHostName, DispatchConsumersAsync = true
};
this.connection = factory.CreateConnection();
this.channel = connection.CreateModel();
channel.QueueDeclare(queue: Constants.WebQueueName, exclusive: false);
this.consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += ProcessWebQueueMessageAsync;
channel.BasicConsume(queue: Constants.WebQueueName,
autoAck: true,
consumer: consumer);
return(Task.CompletedTask);
}
public void ConceptRequestHandler()
{
var channel = queues.connection.CreateModel();
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
Console.WriteLine("Recieved Request for Concepts");
var body = ea.Body;
concept_query = (ConceptRequest)body.DeSerialize(typeof(ConceptRequest));
this.concept_list = new ConceptResponse(concept_query.Username);
this.concept_list.concepts.AddRange(graphfunctions.GetConceptFromTechnology(concept_query.Tech));
channel.BasicAck(ea.DeliveryTag, false);
channel.BasicPublish("KnowldegeGraphExchange", "Routing Key", null, this.concept_list.Serialize());
var routingKey = ea.RoutingKey;
Console.WriteLine(" - Routing Key <{0}>", routingKey);
Console.WriteLine("- Delivery Tag <{0}>", ea.DeliveryTag);
await Task.Yield();
};
channel.BasicConsume("QuizEngine_KnowledgeGraph_Concepts", false, consumer);
}
public void QuestionRequestHandler()
{
var channel = queues.connection.CreateModel();
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
Console.WriteLine("Recieved Request for Questions");
var body = ea.Body;
question_query = (QuestionRequest)body.DeSerialize(typeof(QuestionRequest));
this.questionidlist = new QuestionIdsResponse(batch_query.Username);
this.questionidlist.IdRequestDictionary = (graphfunctions.GetQuestionIds(question_query.Username, question_query.Tech, question_query.Concept));
channel.BasicAck(ea.DeliveryTag, false);
channel.BasicPublish("KnowldegeGraphExchange", "Routing Key", null, this.questionidlist.Serialize());
var routingKey = ea.RoutingKey;
Console.WriteLine(" - Routing Key <{0}>", routingKey);
Console.WriteLine("- Delivery Tag <{0}>", ea.DeliveryTag);
await Task.Yield();
};
channel.BasicConsume("QuizEngine_KnowledgeGraph", false, consumer);
}
public void QuizEngineQueueHandler()
{
var channel = queues.connection.CreateModel();
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += async(model, ea) =>
{
Console.WriteLine("Recieved Request for Questions");
var body = ea.Body;
query = (QuizEngineQuery)body.DeSerialize(typeof(QuizEngineQuery));
IDs.Clear();
IDs.AddRange(graphfunctions.GetQuestionIds(query.tech, query.username));
channel.BasicAck(ea.DeliveryTag, false);
channel.BasicPublish("KnowldegeGraphExchange", "Models.QuestionId", null, IDs.Serialize());
var routingKey = ea.RoutingKey;
Console.WriteLine(" - Routing Key <{0}>", routingKey);
Console.WriteLine("- Delivery Tag <{0}>", ea.DeliveryTag);
await Task.Yield();
};
channel.BasicConsume("QuizEngine_KnowledgeGraph_QuestionBatch", false, consumer);
}
public void Start(IMessageHandlerCallback callback)
{
//throw new NotImplementedException();
_callback = callback;
var factory = new ConnectionFactory()
{
HostName = _host, UserName = _username, Password = _password, DispatchConsumersAsync = true
};
_connection = factory.CreateConnection(_connName);
_model = _connection.CreateModel();
_model.ExchangeDeclare(_exchange, "topic", durable: true, autoDelete: false);
//_model.ExchangeDeclare(_exchange, "fanout", durable: true, autoDelete: false);
_model.QueueDeclare(_queuename, durable: true, autoDelete: false, exclusive: false);
_model.QueueBind(_queuename, _exchange, _routingKey);
_consumer = new AsyncEventingBasicConsumer(_model);
_consumer.Received += Consumer_ReceivedAsync;
_consumerTag = _model.BasicConsume(_queuename, false, _consumer);
}
public string StartMessageConsumer(AsyncEventHandler <BasicDeliverEventArgs> consumeMessageHandler)
{
if (Model == null)
{
throw new RabbitMqWrapperException(
$"{nameof(RabbitMqWrapper)}.{nameof(Start)} must be run before calling {nameof(StartMessageConsumer)}");
}
var consumer = new AsyncEventingBasicConsumer(Model);
consumer.Received += async(sender, @event) => { await consumeMessageHandler(sender, @event); };
var consumerTag = Model.BasicConsume(QueueName, _autoAck, consumer);
Logger.Trace($"{nameof(RabbitMqWrapper)}.{nameof(StartMessageConsumer)}",
new LogItem("Event", "Message handler subscribed to queue"),
new LogItem("QueueName", QueueName),
new LogItem("ConsumerTag", consumerTag),
new LogItem("HandlerMethod", () => consumeMessageHandler.GetMethodInfo().Name));
return(consumerTag);
}
private void StartBasicConsume <T>() where T : Event
{
var factory = new ConnectionFactory
{
HostName = "localhost",
DispatchConsumersAsync = true
};
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
var eventName = typeof(T).Name;
var queueName = channel.QueueDeclare(eventName + "-" + Guid.NewGuid().ToString(), false, false, true, null).QueueName;
channel.ExchangeDeclare(eventName, ExchangeType.Fanout);
channel.QueueBind(queueName, eventName, "");
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += Consumer_Received;
channel.BasicConsume(queueName, true, consumer);
}
public void StartConsuming()
{
if (IsConsuming)
{
return;
}
EnsureConnected();
EnsureConsumerChannelCreated();
EnsureExchangeDeclared(_consumerChannel);
EnsureQueueDeclared(_consumerChannel);
var consumer = new AsyncEventingBasicConsumer(_consumerChannel);
consumer.Received += ConsumerOnReceived;
_consumerChannel.BasicConsume(_rabbitMqConfig.QueueName, false, consumer);
IsConsuming = true;
}
protected override Task ExecuteAsync(CancellationToken cancellationToken)
{
var channel = _messagingFactory.Configure();
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += _messagingService.Dequeue(cancellationToken, async(string raw, NewUserEvent message) =>
{
cancellationToken.ThrowIfCancellationRequested();
if (message == null)
{
return;
}
await _orchestratorService.OrchestrateAsync(message);
});
_tag = channel.BasicConsume(_messaging.Consuming.Queue, false, consumer);
return(Task.CompletedTask);
}
public RpcClient()
{
var factory = new ConnectionFactory()
{
HostName = "localhost"
};
factory.DispatchConsumersAsync = true;
connection = factory.CreateConnection();
channel = connection.CreateModel();
replyQueueName = channel.QueueDeclare().QueueName;
consumer = new AsyncEventingBasicConsumer(channel);
props = channel.CreateBasicProperties();
correlationId = Guid.NewGuid().ToString();
props.CorrelationId = correlationId;
props.ReplyTo = replyQueueName;
consumer.Received += Consumer_Received;
}
public void ConceptResponseHandler()
{
var channel = connection.CreateModel();
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += async(model, ea) => {
Console.WriteLine("<--------------------Recieved Questions--------------------->");
var body = ea.Body;
var data = (ConceptResponse)body.DeSerialize(typeof(ConceptResponse));
Console.WriteLine(data);
Console.WriteLine("<------------------------------------------------------------>");
channel.BasicAck(ea.DeliveryTag, false);
var routingKey = ea.RoutingKey;
Console.WriteLine(" - Routing Key <{0}>", routingKey);
Console.WriteLine("- Delivery Tag <{0}>", ea.DeliveryTag);
await hubContext.Clients.Client(ConnectionData.userconnectiondata[key : data.username]).SendAsync("", data.concepts);
await Task.Yield();
};
channel.BasicConsume("QuizEngine_KnowledgeGraph", false, consumer);
}
protected virtual void TryCreateChannel()
{
DisposeChannel();
try
{
Channel = ConnectionPool.Get(ConnectionName).CreateModel();
Channel.ExchangeDeclare(Exchange.ExchangeName, Exchange.Type, Exchange.Durable, Exchange.AutoDelete, Exchange.Arguments);
Channel.QueueDeclare(Queue.QueueName, Queue.Durable, Queue.Exclusive, Queue.AutoDelete, Queue.Arguments);
var consumer = new AsyncEventingBasicConsumer(Channel);
consumer.Received += HandleIncomingMessageAsync;
Channel.BasicConsume(queue: Queue.QueueName, autoAck: false, consumer: consumer);
}
catch (Exception ex)
{
Logger.LogError(ex, ex.Message);
}
}
private void StartBasicConsume <T>() where T : Event
{
Debug.WriteLine(JsonConvert.SerializeObject(_messageBusSettings));
Debug.Print(JsonConvert.SerializeObject(_messageBusSettings));
var factory = GetConnectionFactory();
factory.DispatchConsumersAsync = true;
var connection = factory.CreateConnection();
var channel = connection.CreateModel();
var eventName = typeof(T).Name;
channel.QueueDeclare(eventName, false, false, false, null);
var consumer = new AsyncEventingBasicConsumer(channel);
consumer.Received += Consumer_Received;
channel.BasicConsume(eventName, true, consumer);
}
public RpcClient(string exchangeName, IRabbitMqConnection connection)
{
_exchangeName = exchangeName;
_connection = connection;
_requestQueue = typeof(TRequest).Name;
_replyQueue = typeof(TReply).Name;
_connection.Connect();
_consumerChannel = _connection.CreateChannel();
_consumerChannel.ExchangeDeclare(_exchangeName, ExchangeType.Direct, true);
_consumerChannel.QueueDeclare(_requestQueue, true, false, false, null);
_consumerChannel.QueueDeclare(_replyQueue, true, false, false, null);
_consumer = new AsyncEventingBasicConsumer(_consumerChannel);
_consumer.Received += Consumer_Received;
_consumerChannel.BasicConsume(_replyQueue, true, _consumer);
_consumerChannel.QueueBind(_replyQueue, _exchangeName, _replyQueue);
_pendingMessages = new ConcurrentDictionary <Guid, TaskCompletionSource <TReply> >();
}
protected override async Task ExecuteAsync(CancellationToken stoppingToken)
{
stoppingToken.ThrowIfCancellationRequested();
var consumer = new AsyncEventingBasicConsumer(_channel);
consumer.Received += async(bc, ea) =>
{
try
{
await ConsumeAsync(ea.Body.ToArray());
_channel.BasicAck(ea.DeliveryTag, false);
}
catch (AlreadyClosedException)
{
_logger.LogInformation("RabbitMQ is closed!");
}
catch (Exception e)
{
_logger.LogError(default, e, "Exception message: {ExceptionMessage}", e.Message);
public void Register()
{
_connection = _factory.CreateConnection();
_channel = _connection.CreateModel();
_channel.QueueDeclare(queue: "deposits", durable: false, exclusive: false, autoDelete: false, arguments: null);
var consumer = new AsyncEventingBasicConsumer(_channel);
consumer.Received += async(model, ea) =>
{
var body = ea.Body;
var message = Encoding.UTF8.GetString(body);
await Task.Run(() =>
{
_creditCommand.Execute(int.Parse(message));
});
};
_channel.BasicConsume(queue: "deposits", autoAck: true, consumer: consumer);
}
