public void Should_raise_message_returned_event_when_message_returned()
        {
            const string exchange = "the exchange";
            const string replyText = "reply text";
            const string routingKey = "routing key";
            var body = new byte[0];
            var properties = new BasicProperties();
            
            publisher.Publish(channelMock, model => { }).Wait();
            
            channelMock.Raise(x => x.BasicReturn += null, null, new BasicReturnEventArgs
                {
                    Body = body,
                    Exchange = exchange,
                    ReplyText = replyText,
                    RoutingKey = routingKey,
                    BasicProperties = properties
                });

            var arg = eventBus.GetArgumentsForCallsMadeOn(x => x.Publish(Arg<ReturnedMessageEvent>.Is.Anything))[0][0];

            var messageEvent = arg as ReturnedMessageEvent;
            Assert.NotNull(messageEvent);
            Assert.AreSame(body, messageEvent.Body);
            Assert.NotNull(messageEvent.Properties);
            Assert.AreEqual(exchange, messageEvent.Info.Exchange);
            Assert.AreEqual(replyText, messageEvent.Info.ReturnReason);
            Assert.AreEqual(routingKey, messageEvent.Info.RoutingKey);
        }
Beispiel #2
0
        static void Main(string[] args)
        {
            var exchg = "socketIOdemo";

            Console.WriteLine("Creating factory...");
            var factory = new ConnectionFactory();

            Console.WriteLine("Creating connection...");
            factory.Protocol = Protocols.FromEnvironment();
            factory.HostName = "localhost";

            var ser = new JavaScriptSerializer();

            using (var conn = factory.CreateConnection())
            using (IModel ch = conn.CreateModel())
            {
                Console.WriteLine("Creating exchange...");
                ch.ExchangeDeclare(exchg, ExchangeType.Fanout, true);
                var props = new BasicProperties()
                {
                    ContentType = "application/json"
                };

                while (true)
                {
                    Console.Write("> ");
                    var txt=Console.ReadLine();
                    var msg = new Message{ body = txt };
                    var serMsg = ser.Serialize(msg);
                    var messageBody = Encoding.UTF8.GetBytes(serMsg);
                    ch.BasicPublish(exchg, string.Empty, props, messageBody);                }
            }
        }
        protected void DeliverMessage(string correlationId, string exceptionMessage)
        {
            var properties = new BasicProperties
            {
                Type = "EasyNetQ.Tests.TestResponseMessage:EasyNetQ.Tests.Messages",
                CorrelationId = correlationId,
                Headers = new Dictionary<string, object>
                {
                    { "IsFaulted", true }
                }
            };

            if (exceptionMessage != null)
            {
                // strings are implicitly convertered in byte[] from RabbitMQ client
                // but not convertered back in string
                // check the source code in the class RabbitMQ.Client.Impl.WireFormatting
                properties.Headers.Add("ExceptionMessage", Encoding.UTF8.GetBytes(exceptionMessage));
            }

            var body = Encoding.UTF8.GetBytes("{}");

            mockBuilder.Consumers[0].HandleBasicDeliver(
                "consumer_tag",
                0,
                false,
                "the_exchange",
                "the_routing_key",
                properties,
                body
                );
        }
        public void Should_be_able_to_subscribe_using_non_generic_extensions()
        {
            var are = new AutoResetEvent(false);
            MyMessage deliveredMessage = null;

            Action<object> onMessage = message =>
                {
                    deliveredMessage = (MyMessage)message;
                    are.Set();
                };

            mockBuilder.Bus.Subscribe(typeof (MyMessage), "subid", onMessage);

            var properties = new BasicProperties
                {
                    Type = "EasyNetQ.Tests.MyMessage:EasyNetQ.Tests"
                };

            var body = Encoding.UTF8.GetBytes("{ Text:\"Hello World\" }");

            mockBuilder.Consumers[0].HandleBasicDeliver(
                "consumer_tag",
                0,
                false,
                "exchange",
                "routing_key",
                properties,
                body);

            are.WaitOne(1000);
            deliveredMessage.ShouldNotBeNull();
            deliveredMessage.Text.ShouldEqual("Hello World");
        }
        public void SetUp()
        {
            mockBuilder = new MockBuilder();

            var queue = new Queue("test_queue", false);

            var are = new AutoResetEvent(false);
            mockBuilder.Bus.Advanced.Consume<ITestMessageInterface>(queue, (message, info) => Task.Factory.StartNew(() =>
                {
                    receivedMessage = message.Body;
                    are.Set();
                }));

            var publishedMessage = new Implementation { Text = "Hello Polymorphs!" };
            var body = new JsonSerializer(new TypeNameSerializer()).MessageToBytes(publishedMessage);
            var properties = new BasicProperties
                {
                    Type = new TypeNameSerializer().Serialize(typeof(Implementation))
                };

            mockBuilder.Consumers[0].HandleBasicDeliver(
                "consumer_tag",
                0,
                false,
                "exchange",
                "routing_key",
                properties,
                body
                );

            are.WaitOne(1000);
        }
Beispiel #6
0
        static void Main(string[] args)
        {
            var factory = new ConnectionFactory
            {
                HostName = "localhost",
                UserName = "******",
                Password = "******"
            };

            var factory2 = new ConnectionFactory
            {
                HostName = "datdb.cphbusiness.dk",
                UserName = "******",
                Password = "******",
                Port = 5672
            };

            var connection = factory.CreateConnection();
            var cphConnection = factory2.CreateConnection();

            var channel = connection.CreateModel();
            channel.QueueDeclare("Bank1Requests", true, false, false, null);

            var cphExchange = cphConnection.CreateModel();
            cphExchange.ExchangeDeclare("cphbusiness.bankXML", "fanout");

            var consumer = new EventingBasicConsumer();
            consumer.Model = channel;
            consumer.Received += (s, e) =>
            {
                var msg = e.Body.ToRequestMessage<CreditScoreMessage>();

                var properties = new BasicProperties();
                properties.ReplyTo = "channel78";

                cphExchange.BasicPublish("cphbusiness.bankXML", "cphbusiness.bankXML", properties, string.Format(@"<LoanRequest>
            <ssn>{0}</ssn>
            <creditScore>{1}</creditScore>
            <loanAmount>{2}</loanAmount>
            <loanDuration>{3}</loanDuration>
            </LoanRequest>", msg.Ssn, msg.CreditScore, msg.Amount, new DateTime(1970, 1, 1).AddDays(msg.Duration).ToString("yyyy-MM-dd " + "00:00:00.0 CET")).ToByteArray());
            };
            channel.BasicConsume("Bank1Requests", true, consumer);

            var cphConsumer = new EventingBasicConsumer();
            var cphChannel = cphConnection.CreateModel();
            cphChannel.QueueDeclare("channel78", true, false, false, null);
            cphConsumer.Model = cphChannel;

            cphConsumer.Received += (s, e) =>
                {
                    int i = 0;
                };
            cphChannel.BasicConsume("channel78", true, cphConsumer);
        }
        public void Should_copy_from_Rabbit_client_properties()
        {
            const string replyTo = "reply to";

            var properties = new MessageProperties();
            var originalProperties = new BasicProperties {ReplyTo = replyTo};

            properties.CopyFrom(originalProperties);

            properties.ReplyTo.ShouldEqual(replyTo);
        }
        protected override void DispatchMessage(object msg)
        {
            Performance<RabbitPerformance>.Counter.IncreaseMessagesProcessedPerSecond();
            Performance<RabbitPerformance>.Counter.IncreaseThreadsUsedPerSecond();
            try
            {
                if (Log.IsDebugEnabled)
                    Log.Debug("Handling message on thread: {0}", Thread.CurrentThread.ManagedThreadId);

                var rabbitMsg = (RabbitMessage)msg;

                var newScope = ComponentLocator.Current.StartChildScope();
                IMessage result;
                using (newScope)
                {
                    new MessagePipeline(MessageHandlerProvider, MessageFormatter, newScope, rabbitMsg, null).Process(out result);
                }

                var correlationId = rabbitMsg.Properties.CorrelationId;
                var queueName = rabbitMsg.Properties.ReplyTo;

                if (String.IsNullOrEmpty(correlationId) || String.IsNullOrEmpty(queueName))
                    return;

                if (Log.IsInfoEnabled)
                    Log.Info("Message has CorrelationId: {0} and response will be sent to: {1}", correlationId, queueName);

                var channel = Connection.Current.CreateModel();
                IBasicProperties props = new BasicProperties
                {
                    CorrelationId = correlationId
                };

                var payload = MessageFormatter.Format(result);

                if (Log.IsDebugEnabled)
                    Log.Debug("Publishing response.");

                channel.BasicPublish(String.Empty, queueName, props, payload);

                if (Log.IsDebugEnabled)
                    Log.Debug("Published response.");
            }
            catch (Exception ex)
            {
                Log.Error("Exception in message handling", ex);
            }
            finally
            {
                QueueUsedThreads--;
                Performance<RabbitPerformance>.Counter.DecrementThreadsCurrentlyUsed();
            }
        }
        // ReSharper disable ConditionIsAlwaysTrueOrFalse
        public static void Exec(bool durable, bool ack, IModel model, IConnection connection)
        {
            var queueName = "CSharpPublish" + (durable ? "Durable" : "NotDurable");
            if (!string.IsNullOrWhiteSpace(_overrideQueueName))
                queueName = _overrideQueueName;

            Console.WriteLine("Durability {0} enabled", durable ? "IS" : "is NOT");
            Console.WriteLine("ACK {0} enabled", ack ? "IS" : "is NOT");

            Console.WriteLine("Creating queue {0}...", queueName);
            model.QueueDeclare(queueName, durable, false, false, null);

            var msg = Encoding.UTF8.GetBytes("Hello from my PC !");
            var properties = new BasicProperties { DeliveryMode = (byte)(durable ? 2 : 1) };

            if (_publish)
            {
                for (int i = 0; i < _numMsgs; i++)
                    model.BasicPublish(string.Empty, queueName, properties, msg);

                Console.WriteLine("Published!");
            }

            uint msgs = 0;
            if (_receive)
            {
                Console.WriteLine("Reading...");
                var fromMac = false;
                while (connection.IsOpen)
                {
                    var result = model.BasicGet(queueName, ack == false);
                    if (result == null)
                        break;

                    if (msgs % 3144 == 0)
                        Console.WriteLine(msgs);

                    if (ack)
                        model.BasicAck(result.DeliveryTag, false);
                    var msgText = Encoding.UTF8.GetString(result.Body);
                    if (msgText.Contains("Mac"))
                        fromMac = true;
                    msgs++;
                }

                if (fromMac)
                {
                    Console.ForegroundColor = ConsoleColor.Blue;
                    Console.WriteLine("Received messages from the mac");
                    Console.ResetColor();
                }
            }
        }
        private static Envelope CreateMessage(String streamId, String type, IDictionary<String, Object> body)
        {
            var meta = new BasicProperties
            {
                AppId = Assembly.GetExecutingAssembly().GetName().Name,
                Type = type,
                MessageId = Guid.NewGuid().ToString(),
                Timestamp = new AmqpTimestamp(DateTime.UtcNow.Ticks),
                Headers = new ListDictionary {{"streamId", streamId}}
            };

            return new Envelope() { Body = body, Meta = meta };
        }
        public void Should_copy_to_rabbit_client_properties()
        {
            const string replyTo = "reply to";

            var properties = new MessageProperties { ReplyTo = replyTo };
            var destinationProperties = new BasicProperties();

            properties.CopyTo(destinationProperties);

            destinationProperties.ReplyTo.ShouldEqual(replyTo);
            destinationProperties.IsReplyToPresent().ShouldBeTrue();
            destinationProperties.IsMessageIdPresent().ShouldBeFalse();
        }
        public void An_exchange_is_bound_to_a_queue()
        {
            Model.ExchangeDeclare("TypeA", ExchangeType.Fanout, true, true, null);
            _queueName = Model.QueueDeclare("TypeA", true, true, true, null);

            Model.QueueBind(_queueName, "TypeA", "");
            Model.QueuePurge(_queueName);

            byte[] message = Encoding.UTF8.GetBytes("HELLO, WORLD.");

            IBasicProperties properties = new BasicProperties();
            properties.Type = "System.string";

            Model.BasicPublish("TypeA", "", properties, message);
        }
        public void PublishMessagesToQueue(IEnumerable<HosepipeMessage> messages, QueueParameters parameters)
        {
            using (var connection = HosepipeConnection.FromParamters(parameters))
            using (var channel = connection.CreateModel())
            {
                foreach (var message in messages)
                {
                    var body = Encoding.UTF8.GetBytes(message.Body);

                    var properties = new BasicProperties();
                    message.Properties.CopyTo(properties);

                    channel.BasicPublish(message.Info.Exchange, message.Info.RoutingKey, properties, body);
                }
            }                        
        }
Beispiel #14
0
 /// <summary>
 /// delivery the message directly into the queue from which it came.
 /// 
 /// You may want to put it back into an exchange instead of a queue.
 /// </summary>
 private void SendMessageToQueue(string queueName, byte[] messageBytes)
 {
     const string exchangeName = "";
     if (string.IsNullOrEmpty(queueName))
     {
         throw new ArgumentNullException("queueName");
     }
     if (messageBytes == null)
     {
         throw new ArgumentNullException("messageBytes");
     }
     var basicProperties = new BasicProperties
     {
         DeliveryMode = 2//2 = durable
     };
     _model.BasicPublish(exchangeName, queueName, basicProperties, messageBytes);
 }
        protected void ReturnResponse()
        {
            var body = Encoding.UTF8.GetBytes("{ \"Text\": \"Hello World!\" }");
            var properties = new BasicProperties
                {
                    Type = "EasyNetQ_Tests_MyOtherMessage:EasyNetQ_Tests"
                };
            var consumerTag = "the_consumer_tag";

            var autoResetEvent = new AutoResetEvent(false);
            var handlerRunning = (HandlerRunner)mockBuilder.ServiceProvider.Resolve<IHandlerRunner>();
            handlerRunning.OnAckSent = () => autoResetEvent.Set();

            mockBuilder.Consumers[0].HandleBasicDeliver(consumerTag, 0, false, "", "rpc_return_queue", properties, body);

            autoResetEvent.WaitOne(500);
        }
        public void HandlingLastErrorMessageCallsFallback()
        {
            var basicProperties = new BasicProperties();
            basicProperties.SetRetryCount(3);
            var basicDeliverEventArgs = new BasicDeliverEventArgs(Guid.NewGuid().ToString(), 0, false,
                                              "Test", "Test", basicProperties, new byte[16]);

            _sut.HandleConsumerError(basicDeliverEventArgs, new Exception("Test"));

            Thread.Sleep(TimeSpan.FromSeconds(4));

            _model.AssertWasNotCalled(x => x.BasicPublish(null, null, null, null), y => y.IgnoreArguments());
            _fallbackStrategy.AssertWasCalled(x => x.HandleConsumerError(null, null), y => y.IgnoreArguments()
                .Message("Expected invocation of fallback strategy!"));

            _logger.AssertWasNotCalled(x => x.ErrorWrite(null, null), y => y.IgnoreArguments()
                .Message("RetryMessageConsumerErrorStrategy should not be called any more at this point!"));
        }
        public void HandleSecondErroredMessage()
        {
            var basicProperties = new BasicProperties();
            basicProperties.SetRetryCount(2);
            var basicDeliverEventArgs = new BasicDeliverEventArgs(Guid.NewGuid().ToString(), 0, false,
                                              "Test", "Test", basicProperties, new byte[16]);

            _sut.HandleConsumerError(basicDeliverEventArgs, new Exception("Test"));

            Thread.Sleep(TimeSpan.FromSeconds(4));

            _model.AssertWasCalled(x => x.BasicPublish(Arg<string>.Is.Equal("Test"),
                Arg<string>.Is.Equal("Test"),
                Arg<IBasicProperties>.Matches(z => z.GetRetryCount() == 3),
                Arg<byte[]>.Is.Anything));

            _logger.AssertWasNotCalled(x => x.ErrorWrite(null, null), y => y.IgnoreArguments());
        }
        private void DeliverMessage(string message, string type)
        {
            var properties = new BasicProperties
            {
                Type = type,
                CorrelationId = "the_correlation_id"
            };
            var body = Encoding.UTF8.GetBytes(message);

            mockBuilder.Consumers[0].HandleBasicDeliver(
                "consumer tag",
                0,
                false,
                "the_exchange",
                "the_routing_key",
                properties,
                body
                );

            WaitForMessageDispatchToComplete();
        }
        public void RegisterResponseAction(Action<IMessage> responseAction, out IBasicProperties basicProperties)
        {
            var correlationId = Guid.NewGuid().ToString();

            basicProperties = new BasicProperties
                                  {
                                      ReplyTo = _queueName,
                                      CorrelationId = correlationId,
                                      DeliveryMode = 1
                                  };

            _responseHandlers.Add(correlationId, responseAction);
        }
        public void SendResponse(MessageContext context, HttpResponsePacket response )
        {
            if (disposed) throw new ObjectDisposedException("Subscriber has been disposed");
            if (String.IsNullOrEmpty(context.ReplyToQueue)) return;

            if (conn == null)
            {
                //TODO: Log this -- it technically shouldn't happen. Also translate to a HTTP Unreachable because it means StartCallbackQueueConsumer didn't create a connection
                throw new ApplicationException("This is Bad");
            }

            //TODO: Channel Pool this connection
            using (IModel channel = conn.CreateModel())
            {

                BasicProperties basicProperties = new BasicProperties { CorrelationId = context.CorrelationId };

                try
                {
                    channel.BasicPublish(String.Empty,
                                    context.ReplyToQueue,
                                    basicProperties,
                                    response.Serialize());
                }
                catch {
                    //TODO: Log execption
                }
            }
        }
Beispiel #21
0
        static void Main(string[] args)
        {
            ConnectionFactory factory = new ConnectionFactory
            {
                HostName = "192.168.16.53",
                Port = 5672,
                UserName = "******",
                Password = "******",
                VirtualHost = "/"
            };

            var pubConnection = factory.CreateConnection();
            var consumeConnection = factory.CreateConnection();
            using (var channel = pubConnection.CreateModel())
            {
                channel.ExchangeDeclare(ExchangeName, ExchangeType.Headers, false, false, null);
                //Dictionary<string, object> headers = null;
                Dictionary<string, object> headers = new Dictionary<string, object>();
                headers["asd"] = "asd";
                channel.QueueDeclare(QueueNameOne, true, false, false, headers);
                channel.QueueBind(QueueNameOne, ExchangeName, String.Empty, headers);
                //channel.QueueDeclare(QueueNameTwo, true, false, false, null);
                //channel.QueueBind(QueueNameTwo, ExchangeName, String.Empty);
            }
            var pool = new WorkPool("MyPoool", 5);
            for (int i = 0; i < 5; i++)
            {
                pool.AddWork(new Consumer(factory.CreateConnection()));
            }
            pool.StartCrawlers();
            //for (int i = 0; i < 5; i++)
            //{
            //    Task.Factory.StartNew(() =>
            //    {
            //        using (var channel = consumeConnection.CreateModel())
            //        {

            //            var consumer = new QueueingBasicConsumer(channel);
            //            channel.BasicConsume(QueueNameOne, true, consumer);
            //            while (true)
            //            {
            //                consumer.Queue.Dequeue();
            //            }
            //        }
            //    });

            //}
            for (int i = 0; i < 2; i++)
            {
                var message = BuildBytes(200);
                Task.Factory.StartNew(() =>
                {
                    using (var channel = pubConnection.CreateModel())
                    {
                        IBasicProperties props = new BasicProperties();
                        props.SetPersistent(true);
                        props.Priority = 9;
                        props.Headers = new Dictionary<string, object>() { { "asd", "asd" } };
                        while (true)
                        {
                            for (int j = 0; j < 100; j++)
                            {
                                channel.BasicPublish(ExchangeName, string.Empty, false, false, props, message);
                            }
                        }
                    }
                });
            }
        }
Beispiel #22
0
		private IBasicProperties GetBasicProperties(AsyncLogEventInfo loggingEvent)
		{
			var @event = loggingEvent.LogEvent;
			
			var basicProperties = new BasicProperties();
			basicProperties.ContentEncoding = "utf8";
			basicProperties.ContentType = "text/plain";
			basicProperties.AppId = AppId ?? @event.LoggerName;

			basicProperties.Timestamp = new AmqpTimestamp(
				Convert.ToInt64((@event.TimeStamp - _Epoch).TotalSeconds));

			// support Validated User-ID (see http://www.rabbitmq.com/extensions.html)
			basicProperties.UserId = UserName;

			return basicProperties;
		}
        private void PublishKeepAlive(IModel ch)
        {
            var keepAlive = _sensuClientConfigurationReader.Configuration.Config["client"];

            keepAlive["timestamp"] = SensuClientHelper.CreateTimeStamp();
            keepAlive["version"] = Version; // Undocumented stuff to send the client version
            keepAlive["plugins"] = "";

            List<string> redactlist = null;

            redactlist = SensuClientHelper.GetRedactlist((JObject) keepAlive);

            var payload = SensuClientHelper.RedactSensitiveInformaton(keepAlive, redactlist);

            Log.Debug("Publishing keepalive");
            var properties = new BasicProperties
                {
                    ContentType = "application/octet-stream",
                    Priority = 0,
                    DeliveryMode = 1
                };
            try
            {
                ch.BasicPublish("", "keepalives", properties, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload)));
            }
            catch (Exception)
            {
                Log.Error("Lost MQ connection when trying to publish keepalives!");
            }
        }
Beispiel #24
0
        private static void Receive(IModel model, QueueingBasicConsumer consumer)
        {
            var request = consumer.Queue.Dequeue() as BasicDeliverEventArgs;
            if (request == null)
            {
                Console.WriteLine("Request is NULL!");
                return;
            }
            else
            {
                var requestObj = request.Body.Deserialize<GetDateRequest>();
                Console.WriteLine("[Server] Received Request: {0}", requestObj.ToJson());

                // Ack the request
                model.BasicAck(request.DeliveryTag, false);

                // Create a reply
                var replyQueue = request.BasicProperties.ReplyTo;
                var correlationId = request.BasicProperties.CorrelationId;

                var replyObj = new GetDateResponse {Timestamp = DateTime.Now};
                var replyProperties = new BasicProperties
                {
                    CorrelationId = correlationId,
                };

                // Send the reply
                Console.WriteLine("[Server] Sending reply...");
                model.BasicPublish("", replyQueue, replyProperties, replyObj.Serialize());

                // Now receive the next message
                Receive(model, consumer);
            }
        }
Beispiel #25
0
 public void PublishResult(JObject payload)
 {
     var json = JsonConvert.SerializeObject(payload);
     Log.Info("Publishing Check to sensu server {0} \n", json);
     using (var ch = _connectionFactory.GetRabbitConnection().CreateModel())
     {
         var properties = new BasicProperties
             {
                 ContentType = "application/octet-stream",
                 Priority = 0,
                 DeliveryMode = 1
             };
         ch.BasicPublish("", "results", properties, Encoding.UTF8.GetBytes(json));
     }
 }
Beispiel #26
0
        public static void Send(object sender, System.Timers.ElapsedEventArgs e)
        {
            Task.Factory.StartNew(() =>
            {
                try
                {
                    if (_connection == null)
                        return;

                    // create a new channel in this thread
                    var sendChannel = _connection.CreateModel();

                    // new correlation ID for this request
                    var myCorrelationId = Guid.NewGuid().ToString();

                    // declare a queue for me to read the response
                    var myQueue = sendChannel.QueueDeclare();

                    // set the correlationId and replyTo queue in the basic properties (this could be done in the Body/Application Layer, but the features are built into AMQP)
                    var requestProperties = new BasicProperties
                    {
                        ReplyTo = myQueue.QueueName,
                        CorrelationId = myCorrelationId,
                    };

                    // Publish a send message
                    sendChannel.BasicPublish("", _incomingRequests, requestProperties, new GetDateRequest { Name = myCorrelationId }.Serialize());
                    Console.WriteLine("[Client] Sent request.  Correlation ID {0}", myCorrelationId);

                    // Now we need to wait for a reply
                    var queuedConsumer = new QueueingBasicConsumer(sendChannel);
                    sendChannel.BasicConsume(myQueue.QueueName, false, queuedConsumer);

                    // Now we wait for a response!
                    var response = queuedConsumer.Queue.Dequeue() as BasicDeliverEventArgs;
                    if (response == null)
                        throw new InvalidOperationException("No response!");

                    var correlationId = response.BasicProperties.CorrelationId;
                    Console.WriteLine("[Client] Received reply for {0}", correlationId);

                    // Deserialize the repsonse
                    var responseObj = response.Body.Deserialize<GetDateResponse>();
                    Console.WriteLine("[Client] Received timestamp {0} it is now {1}\r\n----------------------------------\r\n\r\n", responseObj.Timestamp, DateTime.Now);
                }
                catch (Exception ex)
                {
                    WriteException(ex);
                }
            });
        }
        private static void PublishResult(JObject check)
        {
            var payload = new JObject();
            payload["check"] = check;
            payload["client"] = _configsettings["client"]["name"];

            Log.Info("Publishing Check {0}", JsonConvert.SerializeObject(payload, SerializerSettings));
            using (var ch = GetRabbitConnection().CreateModel())
            {
                var properties = new BasicProperties
                {
                    ContentType = "application/octet-stream",
                    Priority = 0,
                    DeliveryMode = 1
                };
                ch.BasicPublish("", "results", properties, Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload)));
            }
            ChecksInProgress.Remove(check["name"].ToString());
        }
        protected void DeliverMessage(string correlationId)
        {
            var properties = new BasicProperties
            {
                Type = "EasyNetQ.Tests.TestResponseMessage:EasyNetQ.Tests.Messages",
                CorrelationId = correlationId
            };
            var body = Encoding.UTF8.GetBytes("{ Id:12, Text:\"Hello World\"}");

            mockBuilder.Consumers[0].HandleBasicDeliver(
                "consumer_tag",
                0,
                false,
                "the_exchange",
                "the_routing_key",
                properties,
                body
                );
        }
        private static void KeepAliveScheduler()
        {
            IModel ch = null;
            Log.Debug("Starting keepalive scheduler thread");
            while (true)
            {
                if (ch == null || !ch.IsOpen)
                {
                    Log.Error("rMQ Q is closed, Getting connection");
                    var connection = GetRabbitConnection();
                    if (connection == null)
                    {
                        //Do nothing - we'll loop around the while loop again with everything null and retry the connection.
                    }
                    else
                    {
                        ch = connection.CreateModel();
                    }
                }
                if (ch != null && ch.IsOpen)
                {
                    //Valid channel. Good to publish.
                    var payload = _configsettings["client"];
                    payload["timestamp"] =
                        Convert.ToInt64(
                            Math.Round((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0)).TotalSeconds,
                                       MidpointRounding.AwayFromZero));
                    Log.Debug("Publishing keepalive");
                    var properties = new BasicProperties
                        {
                            ContentType = "application/octet-stream",
                            Priority = 0,
                            DeliveryMode = 1
                        };
                    ch.BasicPublish("", "keepalives", properties,
                                    Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(payload)));
                }
                else
                {
                    Log.Error("Valiant attempts to get a valid rMQ connection were in vain. Skipping this keepalive loop.");
                }

                //Lets us quit while we're still sleeping.
                lock (MonitorObject)
                {
                    if (_quitloop)
                    {
                        Log.Warn("Quitloop set, exiting main loop");
                        break;
                    }
                    Monitor.Wait(MonitorObject, KeepAliveTimeout);
                    if (_quitloop)
                    {
                        Log.Warn("Quitloop set, exiting main loop");
                        break;
                    }
                }
            }
        }
        public void An_exchange_is_bound_to_a_highly_available_queue()
        {
            var args = new Hashtable();
            args.Add("x-ha-policy", "all");
            Model.ExchangeDeclare("TypeA", ExchangeType.Fanout, true, true, null);
            _queueName = Model.QueueDeclare("TypeA", true, true, true, args);

            Model.QueueBind(_queueName, "TypeA", "");
            Model.QueuePurge(_queueName);

            byte[] message = Encoding.UTF8.GetBytes("HELLO, WORLD.");

            IBasicProperties properties = new BasicProperties();
            properties.Type = "System.string";

            Model.BasicPublish("TypeA", "", properties, message);
        }