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