Example #1
0
        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);
        }
Example #2
0
        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();
                }
        }
Example #3
0
        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();
                    }
                }
        }
Example #4
0
        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();
                    }
                }
        }
Example #5
0
        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();
                    }
                }
        }