title: RabbitMQ, Pika and reconnection strategy
body: <p>I'm using Pika to process data from RabbitMQ.
  As I seemed to run into different kind of problems I decided to write a small test application to see how I can handle disconnects.</p>
  
  <p>I wrote this test app which does following:</p>
  
  <ol>
  <li>Connect to Broker, retry until successful</li>
  <li>When connected create a queue.</li>
  <li>Consume this queue and put result into a python Queue.Queue(0)</li>
  <li>Get item from Queue.Queue(0) and produce it back into the broker queue.</li>
  </ol>
  
  <p>What I noticed were 2 issues:</p>
  
  <ol>
  <li>When I run my script from one host connecting to rabbitmq on another host (inside a vm) then this scripts exits on random moments without producing an error.</li>
  <li>When I run my script on the same host on which RabbitMQ is installed it runs fine and keeps running.</li>
  </ol>
  
  <p>This might be explained because of network issues, packets dropped although I find the connection not really robust.</p>
  
  <p>When the script runs locally on the RabbitMQ server and I kill the RabbitMQ then the script exits with error: "ERROR pika SelectConnection: Socket Error on 3: 104"</p>
  
  <p>So it looks like I can't get the reconnection strategy working as it should be.  Could someone have a look at the code so see what I'm doing wrong?</p>
  
  <p>Thanks,</p>
  
  <p>Jay</p>
  
  <pre><code>#!/bin/python
  import logging
  import threading
  import Queue
  import pika
  from pika.reconnection_strategies import SimpleReconnectionStrategy
  from pika.adapters import SelectConnection
  import time
  from threading import Lock
  
  class Broker(threading.Thread):
      def __init__(self):
          threading.Thread.__init__(self)
          self.logging = logging.getLogger(__name__)
          self.to_broker = Queue.Queue(0)
          self.from_broker = Queue.Queue(0)
          self.parameters = pika.ConnectionParameters(host='sandbox',heartbeat=True)
          self.srs = SimpleReconnectionStrategy()
          self.properties = pika.BasicProperties(delivery_mode=2)
  
          self.connection = None
          while True:
              try:
                  self.connection = SelectConnection(self.parameters, self.on_connected,  reconnection_strategy=self.srs)
                  break
              except Exception as err:
                  self.logging.warning('Cant connect. Reason: %s' % err)
                  time.sleep(1)
  
          self.daemon=True
      def run(self):
          while True:
              self.submitData(self.from_broker.get(block=True))
          pass
      def on_connected(self,connection):
          connection.channel(self.on_channel_open)
      def on_channel_open(self,new_channel):
          self.channel = new_channel
          self.channel.queue_declare(queue='sandbox', durable=True)
          self.channel.basic_consume(self.processData, queue='sandbox')    
      def processData(self, ch, method, properties, body):
          self.logging.info('Received data from broker')
          self.channel.basic_ack(delivery_tag=method.delivery_tag)
          self.from_broker.put(body)
      def submitData(self,data):
          self.logging.info('Submitting data to broker.')
          self.channel.basic_publish(exchange='',
                      routing_key='sandbox',
                      body=data,
                      properties=self.properties)
  if __name__ == '__main__':
      format=('%(asctime)s %(levelname)s %(name)s %(message)s')
      logging.basicConfig(level=logging.DEBUG, format=format)
      broker=Broker()
      broker.start()
      try:
          broker.connection.ioloop.start()
      except Exception as err:
          print err
  </code></pre>