public static void Main2(int count) { TestUtilitiesClass.PrintThreadId("NewTask.Main2 (Producer)"); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) using (IModel channel = connection.CreateModel()) { channel.QueueDeclare(queue: "task_queue", durable: true, exclusive: false, autoDelete: false, arguments: null); byte[] message = TestUtilitiesClass.GetMessage("FairDispatchConsole"); IBasicProperties properties = channel.CreateBasicProperties(); properties.Persistent = true; for (int i = 0; i < count; i++) { channel.BasicPublish(exchange: "", routingKey: "task_queue", basicProperties: properties, body: message); Console.WriteLine("[FairDispatchConsole] Sent {0} ThreadId: {1}", message, Thread.CurrentThread.ManagedThreadId); Thread.Sleep(TimeSpan.FromSeconds(0.5)); } } }
public static void Main2() { ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) { using (IModel channel = connection.CreateModel()) { channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); int counter = 1; consumer.Received += (model, ea) => { byte[] body = ea.Body; string message = Encoding.UTF8.GetString(body); Console.WriteLine(" [x-con1] Received {0}, counter: {1}, threadId: {2}", message, counter, Thread.CurrentThread.ManagedThreadId); counter++; }; channel.BasicConsume(queue: "hello", autoAck: false, consumer: consumer); Console.WriteLine(" Press [enter] to exit."); Console.ReadLine(); } } }
public static void Main2(string[] args) { ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); IConnection connection = factory.CreateConnection(); IModel channel = connection.CreateModel(); channel.ExchangeDeclare(exchange: "topic_logs", type: "topic"); string queueName = channel.QueueDeclare().QueueName; foreach (string bindingKey in args) { channel.QueueBind(queue: queueName, exchange: "topic_logs", routingKey: bindingKey); } Console.WriteLine("[*] Waiting for messages. To exit press CTRL+C"); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { byte[] body = ea.Body; RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(body); string routingKey = ea.RoutingKey; Console.WriteLine("[x] Received '{0}':'{1}'", routingKey, rabbitMqMessage.ToJsonString()); TestUtilitiesClass.SleepProducer(); }; channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer); }
public static void Main2() { TestUtilitiesClass.WriteLine("RpcServer Main2 started."); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); IConnection connection = factory.CreateConnection(); IModel channel = connection.CreateModel(); TestUtilitiesClass.WriteLine("RpcServer Main2 QueueDeclare: rpc_queue"); channel.QueueDeclare(queue: "rpc_queue", durable: false, exclusive: false, autoDelete: false, arguments: null); channel.BasicQos(0, 1, false); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { TestUtilitiesClass.WriteLine("RpcServer Main2 Received message"); string response = null; byte[] body = ea.Body; IBasicProperties props = ea.BasicProperties; IBasicProperties replyProps = channel.CreateBasicProperties(); replyProps.CorrelationId = props.CorrelationId; TestUtilitiesClass.WriteLine("RpcServer Main2 CorrelationId: " + props.CorrelationId); try { string message = Encoding.UTF8.GetString(body); int n = int.Parse(message); Console.WriteLine("RpcServer Main2 fib({0})", message); response = fib(n).ToString(); } catch (Exception e) { TestUtilitiesClass.WriteLine("RpcServer Main2 Exception " + e.Message); response = ""; } finally { TestUtilitiesClass.WriteLine("RpcServer Main2 finally"); byte[] responseBytes = Encoding.UTF8.GetBytes(response); TestUtilitiesClass.WriteLine("RpcServer Main2 finally BasicPublish routingKey: " + props.ReplyTo); channel.BasicPublish(exchange: "", routingKey: props.ReplyTo, basicProperties: replyProps, body: responseBytes); channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false); } }; TestUtilitiesClass.WriteLine("RpcServer Main2 BasicConsume queue: rpc_queue"); channel.BasicConsume(queue: "rpc_queue", autoAck: false, consumer: consumer); Console.WriteLine("RpcServer Main2 Awaiting RPC requests"); }
public static void Main2() { string[] args = { "a", "b", "c" }; string message = GetMessage(args); byte[] body = Encoding.UTF8.GetBytes(message); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) { using (IModel channel = connection.CreateModel()) { IBasicProperties properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.QueueDeclare(queue: "task_queue", durable: false, exclusive: false, autoDelete: false, arguments: null); channel.BasicPublish(exchange: "", routingKey: "task_queue", basicProperties: properties, body: body); Console.WriteLine(" [x] Worker-Sent {0}", body); } } }
public RpcClient() { TestUtilitiesClass.WriteLine("RpcClient constructor started"); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); connection = factory.CreateConnection(); channel = connection.CreateModel(); replyQueueName = channel.QueueDeclare().QueueName; consumer = new EventingBasicConsumer(channel); TestUtilitiesClass.WriteLine("RpcClient replyQueueName: " + replyQueueName); props = channel.CreateBasicProperties(); string correlationId = Guid.NewGuid().ToString(); TestUtilitiesClass.WriteLine("RpcClient correlationId: " + correlationId); props.CorrelationId = correlationId; props.ReplyTo = replyQueueName; consumer.Received += (model, ea) => { TestUtilitiesClass.WriteLine("RpcClient Received"); byte[] body = ea.Body; string response = Encoding.UTF8.GetString(body); if (ea.BasicProperties.CorrelationId == correlationId) { respQueue.Add(response); } }; }
private static void SendMessage(int count) { ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) { using (IModel channel = connection.CreateModel()) { channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null); for (int i = 0; i < count; i++) { string message = "Publisher Message " + i; byte[] body = Encoding.UTF8.GetBytes(message); channel.BasicPublish(exchange: "", routingKey: "hello", basicProperties: null, body: body); Console.WriteLine(" [x] Sent {0}", message); } } } }
public static void Main2() { TestUtilitiesClass.PrintThreadId("Worker.Main2 (Consumer)"); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); IConnection connection = factory.CreateConnection(); IModel channel = connection.CreateModel(); channel.QueueDeclare(queue: "task_queue", durable: true, exclusive: false, autoDelete: false, arguments: null); channel.BasicQos(prefetchSize: 0, prefetchCount: 1, global: false); Console.WriteLine("[Worker] Waiting for messages."); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { byte[] body = ea.Body; RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(body); Console.WriteLine("[Worker] Received {0} ThreadId: {1}", rabbitMqMessage.ToJsonString(), Thread.CurrentThread.ManagedThreadId); Thread.Sleep(TimeSpan.FromSeconds(1)); Console.WriteLine("[Worker] Done"); channel.BasicAck(deliveryTag: ea.DeliveryTag, multiple: false); }; channel.BasicConsume(queue: "task_queue", autoAck: false, consumer: consumer); }
public static void Main2() { ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) { using (IModel channel = connection.CreateModel()) { channel.QueueDeclare(queue: "hello", durable: false, exclusive: false, autoDelete: false, arguments: null); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { byte[] body = ea.Body; string message = Encoding.UTF8.GetString(body); Console.WriteLine(" [x] Received {0}", message); int dots = message.Split('.').Length - 1; Thread.Sleep(dots * 1000); Console.WriteLine(" [x] Done"); }; channel.BasicConsume(queue: "task_queue", autoAck: true, consumer: consumer); Console.WriteLine(" Press [enter] to exit."); Console.ReadLine(); } } }
public static void Start(int count) { TaskFactory taskFactory = new TaskFactory(); Action action = () => { ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) { using (IModel channel = connection.CreateModel()) { IBasicProperties properties = channel.CreateBasicProperties(); properties.Persistent = true; channel.QueueDeclare(queue: "MessageAcknowledgment", durable: false, exclusive: false, autoDelete: false, arguments: null); for (int i = 0; i < count; i++) { byte[] body = TestUtilitiesClass.GetMessage(i.ToString()); RabbitMqMessage item = TestUtilitiesClass.ParseMessage(body); channel.BasicPublish(exchange: "", routingKey: "MessageAcknowledgment", basicProperties: properties, body: body); Console.WriteLine("Queued {0}", item.ToJsonString()); Console.WriteLine(""); Thread.Sleep(TimeSpan.FromSeconds(0.5)); } } } }; taskFactory.StartNew(action); }
public static void Main2() { TestUtilitiesClass.PrintThreadId("ReceiveLogs"); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); IConnection connection = factory.CreateConnection(); IModel channel = connection.CreateModel(); channel.ExchangeDeclare(exchange: "logs", type: "fanout"); string queueName = channel.QueueDeclare().QueueName; channel.QueueBind(queue: queueName, exchange: "logs", routingKey: ""); Console.WriteLine(" [*] Waiting for logs."); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { byte[] body = ea.Body; RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(body); Console.WriteLine("[ReceiveLogs]: {0}", rabbitMqMessage.ToJsonString()); TestUtilitiesClass.SleepConsumer(); }; channel.BasicConsume(queue: queueName, autoAck: true, consumer: consumer); }
// consumer.Received event not firing when channel.BasicConsume is called // https://groups.google.com/forum/#!topic/rabbitmq-users/l0GQ4w3sYEU public static void HandleMessage(string readerName) { ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); IConnection connection = factory.CreateConnection(); IModel channel = connection.CreateModel(); EventingBasicConsumer consumer = new EventingBasicConsumer(channel); consumer.Received += (model, ea) => { byte[] body = ea.Body; RabbitMqMessage message = TestUtilitiesClass.ParseMessage(body); Console.WriteLine($"[{readerName}] Received {message.ToJsonString()}"); Console.WriteLine(""); Thread.Sleep(TimeSpan.FromSeconds(1)); }; Console.WriteLine($"BasicConsume: {readerName} ThreadId: " + Thread.CurrentThread.ManagedThreadId); Console.WriteLine(""); channel.BasicConsume(queue: "round_robin", autoAck: true, consumer: consumer); }
public static void Main2(string severity) { TestUtilitiesClass.PrintThreadId("EmitLogDirect"); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) using (IModel channel = connection.CreateModel()) { channel.ExchangeDeclare(exchange: "direct_logs", type: ExchangeType.Direct); byte[] body = TestUtilitiesClass.GetMessage("EmitLogDirect " + severity); RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(body); channel.BasicPublish(exchange: "direct_logs", routingKey: severity, basicProperties: null, body: body); Console.WriteLine("[EmitLogDirect] Sent '{0}':'{1}'", severity, rabbitMqMessage); TestUtilitiesClass.SleepProducer(); } }
public static void Main2(int count) { TestUtilitiesClass.PrintThreadId("EmitLog"); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) using (IModel channel = connection.CreateModel()) { channel.ExchangeDeclare(exchange: "logs", type: ExchangeType.Fanout); byte[] body = TestUtilitiesClass.GetMessage("PuttingItAllTogetherConsole"); RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(body); for (int i = 0; i < count; i++) { channel.BasicPublish(exchange: "logs", routingKey: "", basicProperties: null, body: body); Console.WriteLine("Sent {0}", rabbitMqMessage.ToJsonString()); TestUtilitiesClass.SleepProducer(); } } }
public static void Main2(int counter) { TestUtilitiesClass.PrintThreadId("FanoutLogsProducer.Main2"); ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) using (IModel channel = connection.CreateModel()) { channel.ExchangeDeclare("logs", ExchangeType.Fanout); channel.QueueDeclare("logA", durable: false, exclusive: false, autoDelete: false); channel.QueueDeclare("logB", durable: false, exclusive: false, autoDelete: false); channel.QueueDeclare("logC", durable: false, exclusive: false, autoDelete: false); channel.QueueBind("logA", "logs", ""); channel.QueueBind("logB", "logs", ""); channel.QueueBind("logC", "logs", ""); byte[] message = TestUtilitiesClass.GetMessage("FanoutLogsProducer"); RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(message); for (int i = 0; i < counter; i++) { channel.BasicPublish(exchange: "logs", routingKey: "", basicProperties: null, body: message); Console.WriteLine("Published: " + rabbitMqMessage.ToJsonString()); TestUtilitiesClass.SleepProducer(); } } }
public static void Create(int counter) { TestUtilitiesClass.PrintThreadId("TempQueueCreator.Create"); ConnectionFactory connectionFactory = TestUtilitiesClass.GetConnectionFactory(); IConnection connection = connectionFactory.CreateConnection(); IModel channel = connection.CreateModel(); string queueName = channel.QueueDeclare().QueueName; string queueName2 = channel.QueueDeclare().QueueName; string queueName3 = channel.QueueDeclare().QueueName; Console.WriteLine("Temp Queue Created: " + queueName); channel.ExchangeDeclare("tempExc", ExchangeType.Direct); channel.QueueBind(queueName, "tempExc", "routingKey1"); channel.QueueBind(queueName2, "tempExc", "routingKey2"); channel.QueueBind(queueName3, "tempExc", "routingKey1"); for (int i = 0; i < counter; i++) { byte[] message = TestUtilitiesClass.GetMessage("TempQueueCreator"); RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(message); channel.BasicPublish(exchange: "tempExc", routingKey: "routingKey1", basicProperties: null, body: message); Console.WriteLine("Sent {0}", rabbitMqMessage.ToJsonString()); } }
public static void Main2(string[] args, int count) { ConnectionFactory factory = TestUtilitiesClass.GetConnectionFactory(); using (IConnection connection = factory.CreateConnection()) using (IModel channel = connection.CreateModel()) { channel.ExchangeDeclare(exchange: "topic_logs", type: ExchangeType.Topic); string routingKey = (args.Length > 0) ? args[0] : "anonymous.info"; byte[] message = (args.Length > 1) ? TestUtilitiesClass.GetMessage(string.Join(" ", args.Skip(1).ToArray())) : TestUtilitiesClass.GetMessage("Hello World!"); for (int i = 0; i < count; i++) { channel.BasicPublish(exchange: "topic_logs", routingKey: routingKey, basicProperties: null, body: message); RabbitMqMessage rabbitMqMessage = TestUtilitiesClass.ParseMessage(message); Console.WriteLine("[x] Sent '{0}':'{1}'", routingKey, rabbitMqMessage.ToJsonString()); TestUtilitiesClass.SleepProducer(); } } }