public void Subscribe(string queueName, Action<string> callback) { this.Subscriptions = this.Subscriptions ?? Enumerable.Empty<Task>(); this.Subscriptions = this.Subscriptions.Concat(new[] { Task.Factory.StartNew(delegate { var factory = new ConnectionFactory() { VirtualHost = "/", HostName = "127.0.0.1", Port = AmqpTcpEndpoint.UseDefaultPort }; factory.UserName = "******"; factory.Password = "******"; using (var connection = factory.CreateConnection()) { using (var channel = connection.CreateModel()) { var subscription = new Subscription(channel, queueName, false); while(true) { var eventArgs = subscription.Next(); var content = eventArgs == null ? string.Empty : Encoding.UTF8.GetString(eventArgs.Body); subscription.Ack(eventArgs); callback(content); } } } } )}); }
public void ProcessMessages() { using (_connection = _factory.CreateConnection()) { using (var channel = _connection.CreateModel()) { Console.WriteLine("Listening for Topic <payment.*>"); Console.WriteLine("------------------------------"); Console.WriteLine(); channel.ExchangeDeclare(ExchangeName, "topic"); channel.QueueDeclare(AllQueueName, true, false, false, null); channel.QueueBind(AllQueueName, ExchangeName, "payment.*"); channel.BasicQos(0, 10, false); Subscription subscription = new Subscription(channel, AllQueueName, false); while (true) { BasicDeliverEventArgs deliveryArguments = subscription.Next(); var message = deliveryArguments.Body.DeSerializeText(); Console.WriteLine("Message Received '{0}'", message); subscription.Ack(deliveryArguments); } } } }
public void ProcessMessages() { using (_connection = _factory.CreateConnection()) { using (var channel = _connection.CreateModel()) { Console.WriteLine("Listening for Topic <payment.purchaseorder>"); Console.WriteLine("------------------------------------------"); Console.WriteLine(); channel.ExchangeDeclare(ExchangeName, "topic"); channel.QueueDeclare(PurchaseOrderQueueName, true, false, false, null); channel.QueueBind(PurchaseOrderQueueName, ExchangeName, "payment.purchaseorder"); channel.BasicQos(0, 10, false); Subscription subscription = new Subscription(channel, PurchaseOrderQueueName, false); while (true) { BasicDeliverEventArgs deliveryArguments = subscription.Next(); var message = (PurchaseOrder)deliveryArguments.Body.DeSerialize(typeof(PurchaseOrder)); var routingKey = deliveryArguments.RoutingKey; Console.WriteLine("-- Purchase Order - Routing Key <{0}> : {1}, £{2}, {3}, {4}", routingKey, message.CompanyName, message.AmountToPay, message.PaymentDayTerms, message.PoNumber); subscription.Ack(deliveryArguments); } } } }
///<summary>Enters the main loop of the RPC service.</summary> ///<remarks> ///<para> /// Retrieves requests repeatedly from the service's /// subscription. Each request is passed to /// ProcessRequest. Once ProcessRequest returns, the request /// is acknowledged via Subscription.Ack(). If transactional /// mode is enabled, TxCommit is then called. Finally, the /// loop begins again. ///</para> ///<para> /// Runs until the subscription ends, which happens either as /// a result of disconnection, or of a call to Close(). ///</para> ///</remarks> public void MainLoop() { foreach (BasicDeliverEventArgs evt in m_subscription) { ProcessRequest(evt); m_subscription.Ack(); if (m_transactional) { m_subscription.Model.TxCommit(); } } }
private static void blockingReceiveMessages(Subscription sub, long msgCount) { Console.WriteLine("Receiving {0} messages (using a Subscriber)", msgCount); for (int i = 0; i < msgCount; ++i) { Console.WriteLine("Message {0}: {1} (via Subscription.Next())", i, messageText(sub.Next())); Console.WriteLine("Message {0} again: {1} (via Subscription.LatestEvent)", i, messageText(sub.LatestEvent)); sub.Ack(); } Console.WriteLine("Done.\n"); }
private void Consume() { bool autoAck = false; //create a subscription mSubscription = new Subscription(Model, QueueName, autoAck); while (isConsuming) { BasicDeliverEventArgs e = mSubscription.Next(); byte[] body = e.Body; onMessageReceived(body); mSubscription.Ack(e); } }
public static int Main(string[] args) { if (args.Length < 4) { Console.Error.WriteLine("Usage: LogTail <uri> <exchange> <exchangetype> <routingkey>"); Console.Error.WriteLine("RabbitMQ .NET client version "+typeof(IModel).Assembly.GetName().Version.ToString()); Console.Error.WriteLine("Parameters:"); Console.Error.WriteLine(" <uri> = \"amqp://*****:*****@host:port/vhost\""); Console.Error.WriteLine("If the exchange name is the empty string, will instead declare a queue named"); Console.Error.WriteLine("by the routingkey, and consume from that queue."); return 2; } string serverAddress = args[0]; string exchange = args[1]; string exchangeType = args[2]; string routingKey = args[3]; ConnectionFactory cf = new ConnectionFactory(); cf.Uri = serverAddress; using (IConnection conn = cf.CreateConnection()) { using (IModel ch = conn.CreateModel()) { ch.QueueDeclare(routingKey, false, true, true, null); Subscription sub = new Subscription(ch, routingKey); if (exchange != "") { ch.ExchangeDeclare(exchange, exchangeType); ch.QueueBind(routingKey, exchange, routingKey, null); } Console.WriteLine("Consumer tag: " + sub.ConsumerTag); foreach (BasicDeliverEventArgs e in sub) { sub.Ack(e); ProcessSingleDelivery(e); if (Encoding.UTF8.GetString(e.Body) == "quit") { Console.WriteLine("Quitting!"); break; } } return 0; } } }
public void Listen() { Console.WriteLine("Creating channel..."); using (IModel model = conn.CreateModel()) { var subscription = new Subscription(model, "queue", false); //while (true) //{ BasicDeliverEventArgs basicDeliveryEventArgs = subscription.Next(); var command = StreamExtension.Deserialize<Vaccine.Core.Cqrs.Commands.DomainCommand>(basicDeliveryEventArgs.Body); //Encoding.UTF8.GetString(basicDeliveryEventArgs.Body); //Console.WriteLine(((CreateCommand)messageContent).Name); bus.Send(command); subscription.Ack(basicDeliveryEventArgs); //} } }
public void ReceiveHeadersMessageReceiverOne(IModel model) { model.BasicQos(0, 1, false); Subscription subscription = new Subscription(model, _headersQueueOne, false); while (true) { BasicDeliverEventArgs deliveryArguments = subscription.Next(); StringBuilder messageBuilder = new StringBuilder(); String message = Encoding.UTF8.GetString(deliveryArguments.Body); messageBuilder.Append("Message from queue: ").Append(message).Append(". "); foreach (string headerKey in deliveryArguments.BasicProperties.Headers.Keys) { byte[] value = deliveryArguments.BasicProperties.Headers[headerKey] as byte[]; messageBuilder.Append("Header key: ").Append(headerKey).Append(", value: ").Append(Encoding.UTF8.GetString(value)).Append("; "); } Console.WriteLine(messageBuilder.ToString()); subscription.Ack(deliveryArguments); } }
public static void Main(string[] args) { var connectionFactory = new ConnectionFactory {HostName = Settings.RabbitMqHost}; using (var connection = connectionFactory.CreateConnection()) { using (var model = connection.CreateModel()) { var subscription = new Subscription(model, Settings.RabbitMqQueue, false); while (true) { var basicDeliveryEventArgs = subscription.Next(); var messageContent = basicDeliveryEventArgs.Body.To<SimpleMessage>(); System.Console.WriteLine(messageContent.Content); subscription.Ack(basicDeliveryEventArgs); } } } System.Console.ReadLine(); }
public void Start() { try { if (IsListening) return; var serverAddress = "localhost:" + _port; var connectionFactory = new ConnectionFactory { Address = serverAddress }; using (var connection = connectionFactory.CreateConnection()) { using (var channel = connection.CreateModel()) { Log("Opening listener"); string queueName = channel.QueueDeclare(_queueName, false, false, false, null); channel.QueueBind(queueName, "amq.direct", queueName, null); using (_subscription = new Subscription(channel, queueName)) { IsListening = true; while (IsListening) { foreach (BasicDeliverEventArgs eventArgs in _subscription) { //Log(Encoding.UTF8.GetString(eventArgs.Body)); Messenger.Default.Send(new RabbitClientMessage()); _subscription.Ack(); } } } } } } catch (Exception e) { Log(e.Message); } }
static void Main(string[] args) { var url = ConfigurationManager.AppSettings.Get("RabbitMqUrl"); var connectionFactory = new ConnectionFactory {Uri = url}; using ( var connection = connectionFactory.CreateConnection()) using ( var channel = connection.CreateModel()) { const string tracingExchangeName = "amq.rabbitmq.trace"; const string tracingQueueName = "some_tracing_queue"; // Create the queue for subscribing to channel.QueueDeclare(queue: tracingQueueName, durable: false, exclusive: false, autoDelete: true, arguments: null); channel.QueueBind(queue: tracingQueueName,exchange:tracingExchangeName,routingKey: null); // Subscribe to messages using (var subscription = new Subscription(model: channel, queueName: tracingQueueName)) { var messageEncoding = Encoding.UTF8; XmlConfigurator.Configure(); var log = LogManager.GetLogger(typeof (Program)); foreach (BasicDeliverEventArgs message in subscription) { // Process each message var body = messageEncoding.GetString(message.Body); var exchange = message.Exchange; var routingKey = message.RoutingKey; log.InfoFormat("{0}|{1}|{2}",exchange,routingKey,body); subscription.Ack(message); } } } }
public void ProcessMessages() { using (_connection = _factory.CreateConnection()) { using (var channel = _connection.CreateModel()) { Console.WriteLine("Listening for Topic <payment.cardpayment>"); Console.WriteLine("-----------------------------------------"); Console.WriteLine(); channel.ExchangeDeclare(ExchangeName, "topic"); channel.QueueDeclare(CardPaymentQueueName, true, false, false, null); channel.QueueBind(CardPaymentQueueName, ExchangeName, "payment.cardpayment"); channel.BasicQos(0, 10, false); Subscription subscription = new Subscription(channel, CardPaymentQueueName, false); while (true) { BasicDeliverEventArgs deliveryArguments = subscription.Next(); var message = (CardPayment)deliveryArguments.Body.DeSerialize(typeof(CardPayment)); var routingKey = deliveryArguments.RoutingKey; Console.WriteLine("--- Payment - Routing Key <{0}> : {1} : {2}", routingKey, message.CardNumber, message.Amount); subscription.Ack(deliveryArguments); } } } }
private static void ReceiveMessages(Subscription sub) { JavaScriptSerializer jsSerializer = new JavaScriptSerializer(); Console.WriteLine("Receiving messages (using Subscriber's IEnumerator)"); int i = 0; foreach (BasicDeliverEventArgs ev in sub) { Console.WriteLine("Message {0}: {1}", i, messageText(ev)); try { Flipper f = jsSerializer.Deserialize<Flipper>(messageText(ev)); var s = Summary.GetInfo(f); Twillio t = new Twillio() { phone = s.PersonSummaryService.response.contact_information.work_phone, message = f.message }; if (t.Send()) { sub.Ack(); Console.WriteLine("TEXT SENT"); } else Console.WriteLine("TEXT FAILED"); } catch (Exception x) { Console.WriteLine("Problem {0}: {1}", i, x.Message); } i++; } Console.WriteLine("Done.\n"); }
public void SubscribeWithSubscriber() { WithChannel.Do(channel => { var subscription = new Subscription(channel, ackNackQueue); foreach (BasicDeliverEventArgs deliverEventArgs in subscription) { var message = Encoding.UTF8.GetString(deliverEventArgs.Body); Console.Out.WriteLine("message = {0}", message); subscription.Ack(deliverEventArgs); } }); }
public void ListenToQueue(string route,NetworkCredential credential) { while (true) { try { var connectionFactory = new ConnectionFactory { HostName = credential.Domain, UserName = credential.UserName, Password = credential.Password, }; var conn = connectionFactory.CreateConnection(); var model = conn.CreateModel(); var queue = model.QueueDeclare(route, true, false, false, null); var sub = new Subscription(model, route); using (conn) { using (model) { foreach (BasicDeliverEventArgs e in sub) { var msg = DeserializeFromJson(Encoding.UTF8.GetString(e.Body)); if (OnMessageReceived != null) OnMessageReceived(msg); sub.Ack(e); } } } } catch (Exception) { Thread.Sleep(1000); } } }
private void RunConsumer( string queueName) { new Task(() => { var _channel = this.c_connection.CreateModel(); var _consumer = new Subscription(_channel, queueName); foreach (BasicDeliverEventArgs _messageDelivery in _consumer) { this.c_writeLog(string.Format("Received message on q {0}, tag = {1}", queueName, _messageDelivery.DeliveryTag)); _consumer.Ack(_messageDelivery); } }).Start(); }
protected void Page_Load(object sender, EventArgs e) { try { var connectionFactory = new ConnectionFactory(); connectionFactory.HostName = ConfigurationManager.AppSettings["hostname"]; connectionFactory.UserName = ConfigurationManager.AppSettings["username"]; connectionFactory.Password = ConfigurationManager.AppSettings["password"]; connectionFactory.Port = Convert.ToInt32(ConfigurationManager.AppSettings["port"]); connectionFactory.VirtualHost = ConfigurationManager.AppSettings["vhost"]; connectionFactory.Protocol = Protocols.FromEnvironment(); //Response.Write(connectionFactory.HostName + " " + connectionFactory.UserName + " " + // connectionFactory.Port.ToString() + " " + connectionFactory.Password); string message = "Hello!!"; //send message to queue using (IConnection connection = connectionFactory.CreateConnection()) { using (IModel model = connection.CreateModel()) { model.ExchangeDeclare("MyExchange", ExchangeType.Fanout, true); model.QueueDeclare("MyQueue", true, false, false, new Dictionary<string, object>()); model.QueueBind("MyQueue", "MyExchange", "", new Dictionary<string, object>()); IBasicProperties basicProperties = model.CreateBasicProperties(); model.BasicPublish("MyExchange", "", false, false, basicProperties, Encoding.UTF8.GetBytes(message)); } } //consume message from queue using (IConnection connection = connectionFactory.CreateConnection()) { using (IModel model = connection.CreateModel()) { var subscription = new Subscription(model, "MyQueue", false); while (true) { BasicDeliverEventArgs basicDeliveryEventArgs = subscription.Next(); string messageContent = Encoding.UTF8.GetString(basicDeliveryEventArgs.Body); //Response.Write(messageContent); subscription.Ack(basicDeliveryEventArgs); if (messageContent == message) { break; } } } } Response.Write("OK"); } catch (Exception ex) { Response.StatusCode = 500; if (ex.InnerException != null) Response.Write(ex.InnerException.Message); Response.Write(ex.Message + Environment.NewLine + ex.StackTrace); } }
private IMessage Receive (IModel model, int timeout, bool doAck, IsMatch matcher) { string finalName = model.QueueDeclare (QRef.Queue, false); using (Subscription sub = new Subscription (model, finalName)) { BasicDeliverEventArgs result; while (sub.Next (timeout, out result)) { if (matcher (result)) { IMessage m = helper.ReadMessage (QRef, result); if (doAck) sub.Ack (result); return m; } } throw new MessageUnavailableException ("Message not available"); } }
private IMessage Receive (IModel model, int timeout, bool doAck) { string finalName = model.QueueDeclare (QRef.Queue, false); using (Subscription sub = new Subscription (model, finalName)) { BasicDeliverEventArgs result; if (sub.Next (timeout, out result)) { IMessage m = helper.ReadMessage (QRef, result); if (doAck) sub.Ack (result); return m; } else { throw new MonoMessagingException ("No Message Available"); } } }
private static void enumeratingReceiveMessages(Subscription sub, long msgCount) { Console.WriteLine("Receiving {0} messages (using Subscriber's IEnumerator)", msgCount); int i = 0; foreach (BasicDeliverEventArgs ev in sub) { Console.WriteLine("Message {0}: {1}", i, messageText(ev)); if (++i == msgCount) break; sub.Ack(); } Console.WriteLine("Done.\n"); }
public ICommand Publish(ICommand command, PublicationAddress receiver, TimeSpan? timeout = null) { if (!timeout.HasValue) timeout = TimeSpan.MaxValue; var props = this.Channel.CreateBasicProperties(); //props.AppId; //props.ClusterId; //props.CorrelationId; props.DeliveryMode = Constants.Persistent; //props.Expiration; //props.Headers; //props.MessageId; //props.Priority; //props.ProtocolClassId; //props.ProtocolClassName; //props.ReplyTo; props.ReplyToAddress = new PublicationAddress(this.CmdExchange.ExchangeType, this.CmdExchange.Name, this.PrivateQueue.Name); //props.Timestamp; //props.UserId; var reqBytes = CommandSerializer.Serialize(command); props.ContentEncoding = CommandSerializer.ContentEncoding; props.ContentType = CommandSerializer.ContentType; props.Type = command.GetType().FullName; // at this point, we're ready to send // set up to receive the response before the send occurs // so there's no chance it'll be missed ICommand reply = null; using (CancellationTokenSource cts = new CancellationTokenSource()) { var ct = cts.Token; Task replyTask = null; if (command.CorrelationId.HasValue) { props.CorrelationId = command.CorrelationId.ToString(); replyTask = Task.Run(() => { var autoAck = false; using (var subscription = new Subscription(this.Channel, this.PrivateQueue.Name, autoAck)) { var subscriptionTimeout = TimeSpan.FromMilliseconds(100d).Milliseconds; while (!ct.IsCancellationRequested) { BasicDeliverEventArgs eventArgs = null; subscription.Next(subscriptionTimeout, out eventArgs); if (eventArgs != null && !ct.IsCancellationRequested) { reply = CommandDeserializer.Deserialize(eventArgs.Body) as ICommand; if (reply != null && reply.CorrelationId == command.CorrelationId) { subscription.Ack(eventArgs); break; } else subscription.Model.BasicNack(eventArgs.DeliveryTag, false, true); } } } }); } // now the receiver is set up, publish the command this.Channel.BasicPublish(receiver, props, reqBytes); //Console.WriteLine("{0} Command sent ({1})", command.GetType().Name, command.CorrelationId); if (timeout < TimeSpan.MaxValue) cts.CancelAfter(timeout.Value); replyTask.Wait(); return reply; } }
public void ReceiveTopicMessageReceiverTwo(IModel model) { model.BasicQos(0, 1, false); Subscription subscription = new Subscription(model, _topicsQueueTwo, false); while (true) { BasicDeliverEventArgs deliveryArguments = subscription.Next(); String message = Encoding.UTF8.GetString(deliveryArguments.Body); Console.WriteLine("Message from queue: {0}", message); subscription.Ack(deliveryArguments); } }
private void QueChannel(CommandBus bus) { using (IModel model = conn.CreateModel()) { var subscription = new Subscription(model, "queue", false); while (true) { BasicDeliverEventArgs basicDeliveryEventArgs = subscription.Next(); var @event = StreamExtension.Deserialize<Vaccine.Events.DomainEvent>(basicDeliveryEventArgs.Body); //Encoding.UTF8.GetString(basicDeliveryEventArgs.Body); Console.WriteLine(@event.GetType()); bus.Publish(@event); subscription.Ack(basicDeliveryEventArgs); } } }
private IMessage ReceiveWithMatcher (QueueReference qRef, int timeout, IsMatch matcher, bool ack) { IModel _model = Model; string finalName = _model.QueueDeclare (qRef.Queue, false); using (Subscription sub = new Subscription (_model, finalName)) { BasicDeliverEventArgs result; while (sub.Next (timeout, out result)) { if (matcher (result)) { IMessage m = helper.ReadMessage (qRef, result); if (ack) sub.Ack (result); return m; } } throw new MessageUnavailableException ("Message not available"); } }