static void Main(string[] args) { var factory = new ConnectionFactory { HostName = "localhost", UserName = "******", Password = "******", }; var connection = factory.CreateConnection(); var channel = connection.CreateModel(); channel.QueueDeclare("LoanRequests", true, false, false, null); var subscription = new Subscription(channel, "LoanRequests", false); for (int i = 1; i < 10; i++) { var message = new LoanRequestMessage { Amount = i * 10000, Duration = i * 10, Ssn = 12312312 }; channel.BasicPublish("", "LoanRequests", null, message.ToByteArray()); Console.WriteLine("Created the following message: "); Console.WriteLine("SSN: " + message.Ssn); Console.WriteLine("Amount: " + message.Amount); Console.WriteLine("Duration: " + message.Duration); } Environment.Exit(0); }
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 static int Main(string[] args) { if (args.Length < 1) { Console.Error.WriteLine("Usage: Subscriber <uri> [<message count>]"); 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\""); return 2; } string serverAddress = args[0]; long msgCount = (args.Length > 1) ? int.Parse(args[1]) : 10; ConnectionFactory cf = new ConnectionFactory(); cf.Uri = serverAddress; using (IConnection conn = cf.CreateConnection()) { using (IModel ch = conn.CreateModel()) { string queueName = ensureQueue(ch); /* We'll consume msgCount message twice: once using Subscription.Next() and once using the IEnumerator interface. So, we'll send out 2*msgCount messages. */ sendMessages(ch, queueName, 2*msgCount); using (Subscription sub = new Subscription(ch, queueName)) { blockingReceiveMessages(sub, msgCount); enumeratingReceiveMessages(sub, msgCount); } } } return 0; }
static void Main(string[] args) { var cf = new ConnectionFactory(); cf.Endpoint.HostName = "localhost"; cf.Password = "******"; cf.UserName = "******"; using (IConnection conn = cf.CreateConnection()) { using (IModel ch = conn.CreateModel()) { string queueName = ensureQueue(ch); /* We'll consume msgCount message twice: once using Subscription.Next() and once using the IEnumerator interface. So, we'll send out 2*msgCount messages. */ using (var sub = new Subscription(ch, queueName)) { blockingReceiveMessages(sub, 100); } } } return; }
/// <summary> /// Initializes a new instance of the <see cref="RabbitMqEventConsumer"/> class. /// </summary> /// <param name="connectionFactory">The connection factory.</param> /// <param name="exchangePath">The exchange path.</param> /// <param name="queue">The queue.</param> public RabbitMqEventConsumer(ConnectionFactory connectionFactory, string exchangePath, string queue) { _active = 1; _connection = connectionFactory.CreateConnection(); _model = _connection.CreateModel(); _queue = _model.QueueDeclare(queue, true, false, false, new Hashtable()); // bind the queue to an exchange if specified if (exchangePath != null) { _model.QueueBind(_queue, exchangePath, string.Empty); } EventingBasicConsumer eventingBasicConsumer = new EventingBasicConsumer(); eventingBasicConsumer.Received += HandleEvent; _model.BasicConsume(_queue, true, eventingBasicConsumer); #if false _subscription = new Subscription(_model, _queue, true); var thread = new Thread(ReceiveEvents); thread.IsBackground = true; thread.Name = "rabbitmq:consumer"; thread.Start(); #endif var uriBuilder = new UriBuilder( "rabbitmq", connectionFactory.HostName, connectionFactory.Port, queue); Uri = uriBuilder.Uri; }
public RabbitMqMessageQueue(string connectionString, string inputQueueName) { this.inputQueueName = inputQueueName; Log.Info("Opening Rabbit connection"); connection = new ConnectionFactory {Uri = connectionString}.CreateConnection(); Log.Debug("Creating model"); model = connection.CreateModel(); Log.Info("Initializing exchange and input queue"); var tempModel = connection.CreateModel(); Log.Debug("Ensuring that exchange exists with the name {0}", ExchangeName); tempModel.ExchangeDeclare(ExchangeName, ExchangeType.Topic, true); Log.Debug("Declaring queue {0}", this.inputQueueName); tempModel.QueueDeclare(this.inputQueueName, true, false, false, new Hashtable()); Log.Debug("Binding {0} to {1} (routing key: {2})", this.inputQueueName, ExchangeName, this.inputQueueName); tempModel.QueueBind(this.inputQueueName, ExchangeName, this.inputQueueName); Log.Debug("Opening subscription"); subscription = new Subscription(model, inputQueueName); }
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); } } } }
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 Subscribe(string queueName) { ch.QueueBind(queueName, "amq.direct", queueName, false, null); using (Subscription sub = new Subscription(ch, queueName)) { ReceiveMessages(sub); } }
public void StartListening(Action<byte[], IDictionary<string, object>> onMessage) { if (this.IsListening) throw new InvalidOperationException("Client is already listening for messages"); Action subscribeAction = () => { try { subscriptionLifetimeResetEvent.Reset(); Subscription subscriptionHandler = new Subscription(this.Connection.GetModel(), this.QueueName); int waitForMessagesTimeout = 100; this.loopControlResetEvent.Reset(); while (!loopControlResetEvent.IsSet) { try { BasicDeliverEventArgs delivery = null; if (subscriptionHandler.Next(waitForMessagesTimeout, out delivery)) { if (delivery == null) continue; // Deliver message var p = CreateProperties(delivery); onMessage(delivery.Body, p); } } catch (ThreadAbortException) { // Nothing to do, thread is being aborted. // Set the reset event to leave gracefully loopControlResetEvent.Set(); } catch (Exception) { // Any other exception should be ignored. } } // Close the subscription if its still open if (subscriptionHandler.Model.IsOpen) { subscriptionHandler.Close(); } } finally { subscriptionLifetimeResetEvent.Set(); } }; this.currentSubscription = subscribeAction; }
private int OneConsumer() { using (var connection = Helpers.CreateConnectionToSecondaryVirtualHostOnAlternativePort()) using (var model = connection.CreateModel()) { var queue = model.QueueDeclare(); model.QueueBind(queue, Constants.FederationExchangeName, "#"); var subscription = new Subscription(model, queue, true); consumerReady.Set(); return subscription.Next().Body.Integer(); } }
/// <summary> /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. /// </summary> public override void Dispose() { if (Interlocked.CompareExchange(ref _active, 1, 0) == 1) { _subscription.Close(); _subscription = null; _model.Dispose(); _model = null; _connection.Dispose(); _connection = null; } }
protected void TestSequentialIterationWithDrainer(Action<Subscription> action) { IDictionary<string, object> args = new Dictionary<string, object> { {Headers.XMessageTTL, 5000} }; string queueDeclare = Model.QueueDeclare("", false, true, false, args); var subscription = new Subscription(Model, queueDeclare, false); PreparedQueue(queueDeclare); var drainer = new SubscriptionDrainer(subscription, action); drainer.Drain(); }
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 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(); }
public void TestConsumerCancellationNotification() { var q = Guid.NewGuid().ToString(); this.Model.QueueDeclare(queue: q, durable: false, exclusive: false, autoDelete: false, arguments: null); var sub = new Subscription(this.Model, q); var latch = new ManualResetEvent(false); sub.Consumer.ConsumerCancelled += (_sender, _args) => { sub.Close(); latch.Set(); Conn.Close(); }; this.Model.QueueDelete(q); Wait(latch, TimeSpan.FromSeconds(4)); }
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); } }
static void Main() { // Set up the RabbitMQ connection and channel var connectionFactory = new ConnectionFactory { HostName = "localhost", Port = 5672, UserName = "******", Password = "******", Protocol = Protocols.AMQP_0_9_1, RequestedFrameMax = UInt32.MaxValue, RequestedHeartbeat = UInt16.MaxValue }; using (var connection = connectionFactory.CreateConnection()) { using (var channel = connection.CreateModel()) { // This instructs the channel not to prefetch more than one message channel.BasicQos(0, 1, false); // Create a new, durable exchange channel.ExchangeDeclare("sample-ex", ExchangeType.Direct, true, false, null); // Create a new, durable queue channel.QueueDeclare("sample-queue", true, false, false, null); // Bind the queue to the exchange channel.QueueBind("sample-queue", "sample-ex", "optional-routing-key"); using (var subscription = new Subscription(channel, "sample-queue", false)) { Console.WriteLine("Waiting for messages..."); var encoding = new UTF8Encoding(); while (channel.IsOpen) { BasicDeliverEventArgs eventArgs; var success = subscription.Next(2000, out eventArgs); if (success == false) continue; var msgBytes = eventArgs.Body; var message = encoding.GetString(msgBytes); Console.WriteLine(message); channel.BasicAck(eventArgs.DeliveryTag, false); } } } } }
public void Close () { if (subscription != null) { subscription.Close (); subscription = null; } if (model != null) { model.Dispose (); model = null; } if (cn != null) { cn.Dispose (); cn = null; } }
/// <remarks> /// RabbitMq does not have a Peek feature, the solution is to dequeue all messages /// without acknowledging them (noAck = true). After all messages have been read /// we dispose the RabbitMqJobQueue causing the channel to close. All unack'd /// messages then get requeued in order. /// </remarks> public IEnumerable<int> GetEnqueuedJobIds(string queue, int @from, int perPage) { using (var client = new RabbitMqJobQueue(new[] {queue}, _factory)) { var consumer = new Subscription(client.Channel, queue, true); List<int> jobIds = new List<int>(); BasicDeliverEventArgs delivery; while (consumer.Next(1000, out delivery)) { var body = Encoding.UTF8.GetString(delivery.Body); jobIds.Add(Convert.ToInt32(body)); } return jobIds.Skip(@from).Take(perPage); } }
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 static IEnumerable<LogData> GetAllMessages() { using (IConnection connection = SetUpFixture.ConnectionFactory.CreateConnection()) { using (IModel model = connection.CreateModel()) { var subscription = new Subscription(model, SetUpFixture.QueueName); BasicDeliverEventArgs basicDeliveryEventArgs; while (subscription.Next(1000, out basicDeliveryEventArgs)) { var logs = (Body) XmlSerializer.Deserialize(new MemoryStream(basicDeliveryEventArgs.Body)); foreach (var entry in logs.LogDatas) { yield return entry; } } } } }
public static int Main(string[] args) { if (args.Length < 1) { Console.Error.WriteLine("Usage: AddServer <hostname>[:<portnumber>]"); Console.Error.WriteLine("RabbitMQ .NET client version "+typeof(IModel).Assembly.GetName().Version.ToString()); return 2; } ConnectionFactory cf = new ConnectionFactory(); cf.Address = args[0]; using (IConnection conn = cf.CreateConnection()) { using (IModel ch = conn.CreateModel()) { ch.QueueDeclare("AddServer", false, false, false, null); Subscription sub = new Subscription(ch, "AddServer"); new AddServer(sub).MainLoop(); } } return 0; }
public static int Main(string[] args) { if (args.Length < 1) { Console.Error.WriteLine("Usage: AddServer <uri>"); 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\""); return 2; } ConnectionFactory cf = new ConnectionFactory(); cf.Uri = args[0]; using (IConnection conn = cf.CreateConnection()) { using (IModel ch = conn.CreateModel()) { ch.QueueDeclare("AddServer", false, false, false, null); Subscription sub = new Subscription(ch, "AddServer"); new AddServer(sub).MainLoop(); } } 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 int Main(string[] args) { if (args.Length < 1) { Console.Error.WriteLine("Usage: ShutdownableServer <hostname>[:<portnumber>]"); Console.Error.WriteLine("RabbitMQ .NET client version "+typeof(IModel).Assembly.GetName().Version.ToString()); return 2; } ConnectionFactory cf = new ConnectionFactory(); cf.Address = args[0]; using (IConnection conn = cf.CreateConnection()) { using (IModel ch = conn.CreateModel()) { Subscription sub = new Subscription(ch, "ShutdownableServer"); new ShutdownableServer(sub).MainLoop(); Console.Out.WriteLine("Returned from MainLoop."); } } Console.Out.WriteLine("Leaving the program."); return 0; }
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 TestChannelClosureIsObservableOnSubscription() { string q = Model.QueueDeclare(); Subscription sub = new Subscription(Model, q, true); BasicDeliverEventArgs r1; Assert.IsFalse(sub.Next(100, out r1)); Model.BasicPublish("", q, null, enc.GetBytes("a message")); Model.BasicPublish("", q, null, enc.GetBytes("a message")); BasicDeliverEventArgs r2; Assert.IsTrue(sub.Next(1000, out r2)); Assert.IsNotNull(sub.Next()); Model.Close(); Assert.IsNull(sub.Next()); BasicDeliverEventArgs r3; Assert.IsFalse(sub.Next(100, out r3)); }
///<summary>Create, but do not start, an instance that will ///receive requests via the given Subscription.</summary> ///<remarks> ///<para> /// The instance is initially in non-transactional mode. See /// SetTransactional(). ///</para> ///<para> /// Call MainLoop() to start the request-processing loop. ///</para> ///</remarks> public SimpleRpcServer(Subscription subscription) { m_subscription = subscription; m_transactional = false; }
static void Main(string[] args) { try { ConnectionFactory cf = new ConnectionFactory(); cf.Uri = "amqps://<user>:<pass>@<server>:5671/"; cf.Ssl.CertPath = "C:\\keycert.p12"; cf.Ssl.CertPassphrase = "<ClientCertPass>"; cf.Ssl.Enabled = true; using (IConnection conn = cf.CreateConnection()) { Console.WriteLine("Connection established"); using (IModel ch = conn.CreateModel()) { ch.BasicQos(0, 1, false); // noAck Subscription sub = new Subscription(ch, "QueueName", true); // last param MUST BE true while (true) { BasicDeliverEventArgs e = sub.Next(); byte[] body = e.Body; Console.WriteLine(Encoding.UTF8.GetString(body)); } } } } catch (Exception ex) { Console.WriteLine(ex.ToString()); } }