Python TornadoConnection.add_timeout方法代码示例

# 需要导入模块: from pika.adapters.tornado_connection import TornadoConnection [as 别名]
# 或者: from pika.adapters.tornado_connection.TornadoConnection import add_timeout [as 别名]
class PikaPublisher(object):

    def __init__(self, amqp_parameters, exchange, exchange_type, queue, routing_key):
        self._exchange = exchange
        self._exchange_type = exchange_type
        self._queue = queue
        self._routing_key = routing_key

        self._connection = None
        self._channel = None
        self._deliveries = []
        self._acked = 0
        self._nacked = 0
        self._message_number = 0
        self._stopping = False
        self._params = amqp_parameters
        self._closing = False

        logging.basicConfig(level=logging.INFO, format=LOG_FORMAT)

    def connect(self):
        self._connection = TornadoConnection(self._params, self.on_connection_open, stop_ioloop_on_close=False)

        LOGGER.info('Adding connection close callback')
        self._connection.add_on_close_callback(self.on_connection_closed)
        return self._connection

    def close_connection(self):
        LOGGER.info('Closing connection')
        self._closing = True
        self._connection.close()

    def on_connection_closed(self, connection, reply_code, reply_text):
        self._channel = None
        if self._closing:
            self._connection.ioloop.stop()
        else:
            LOGGER.warning('Connection closed, reopening in 5 seconds: (%s) %s',
                           reply_code, reply_text)
            self._connection.add_timeout(5, self.reconnect)

    def on_connection_open(self, unused_connection):
        LOGGER.info('Connection opened')
        self.open_channel()

    def reconnect(self):
        # This is the old connection IOLoop instance, stop its ioloop
        self._connection.ioloop.stop()

        # Create a new connection
        self._connection = self.connect()

        # There is now a new connection, needs a new ioloop to run
        self._connection.ioloop.start()

    def add_on_channel_close_callback(self):
        LOGGER.info('Adding channel close callback')
        self._channel.add_on_close_callback(self.on_channel_closed)

    def on_channel_closed(self, channel, reply_code, reply_text):
        LOGGER.warning('Channel was closed: (%s) %s', reply_code, reply_text)
        if not self._closing:
            self._connection.close()

    def on_channel_open(self, channel):
        LOGGER.info('Channel opened')
        self._channel = channel
        self.add_on_channel_close_callback()
        self.setup_exchange(self._exchange)

    def setup_exchange(self, exchange_name):
        LOGGER.info('Declaring exchange %s', exchange_name)
        self._channel.exchange_declare(self.on_exchange_declareok,
                                       exchange_name,
                                       self._exchange_type, durable=True)

    def on_exchange_declareok(self, unused_frame):
        LOGGER.info('Exchange declared')
        self.setup_queue(self._queue)

    def setup_queue(self, queue_name):
        LOGGER.info('Declaring queue %s', queue_name)
        self._channel.queue_declare(self.on_queue_declareok, queue_name, durable = True)

    def on_queue_declareok(self, method_frame):
        LOGGER.info('Binding %s to %s with %s',
                    self._exchange, self._queue, self._routing_key)
        self._channel.queue_bind(self.on_bindok, self._queue,
                                 self._exchange, self._routing_key)

    def on_delivery_confirmation(self, method_frame):
        confirmation_type = method_frame.method.NAME.split('.')[1].lower()
        LOGGER.info('Received %s for delivery tag: %i',
                    confirmation_type,
                    method_frame.method.delivery_tag)
        if confirmation_type == 'ack':
            self._acked += 1
        elif confirmation_type == 'nack':
            self._nacked += 1
        self._deliveries.remove(method_frame.method.delivery_tag)
#.........这里部分代码省略.........

# 需要导入模块: from pika.adapters.tornado_connection import TornadoConnection [as 别名]
# 或者: from pika.adapters.tornado_connection.TornadoConnection import add_timeout [as 别名]

#.........这里部分代码省略.........
    confirmation_type = method_frame.method.NAME.split('.')[1].lower()
    LOGGER.info('Received %s for delivery tag: %i',
          confirmation_type,
          method_frame.method.delivery_tag)
    if confirmation_type == 'ack':
      self._acked += 1
    elif confirmation_type == 'nack':
      self._nacked += 1
    self._deliveries.remove(method_frame.method.delivery_tag)
    LOGGER.info('Published %i messages, %i have yet to be confirmed, '
          '%i were acked and %i were nacked',
          self._message_number, len(self._deliveries),
          self._acked, self._nacked)

  def enable_delivery_confirmations(self):
    """Send the Confirm.Select RPC method to RabbitMQ to enable delivery
    confirmations on the channel. The only way to turn this off is to close
    the channel and create a new one.

    When the message is confirmed from RabbitMQ, the
    on_delivery_confirmation method will be invoked passing in a Basic.Ack
    or Basic.Nack method from RabbitMQ that will indicate which messages it
    is confirming or rejecting.

    """
    LOGGER.info('Issuing Confirm.Select RPC command')
    self._channel.confirm_delivery(self.on_delivery_confirmation)

  def publish_message(self):
    """If the class is not stopping, publish a message to RabbitMQ,
    appending a list of deliveries with the message number that was sent.
    This list will be used to check for delivery confirmations in the
    on_delivery_confirmations method.

    Once the message has been sent, schedule another message to be sent.
    The main reason I put scheduling in was just so you can get a good idea
    of how the process is flowing by slowing down and speeding up the
    delivery intervals by changing the PUBLISH_INTERVAL constant in the
    class.

    """
    if self._stopping:
      return

    message = 'The current epoch value is %i' % time.time()
    properties = pika.BasicProperties(app_id='example-publisher',
                      content_type='text/plain')

    self._channel.basic_publish(rc.valueExngAttr["exchange"], self.ROUTING_KEY,
                  message, properties)
    self._message_number += 1
    self._deliveries.append(self._message_number)
    LOGGER.info('Published message # %i', self._message_number)
    self.schedule_next_message()

  def schedule_next_message(self):
    """If we are not closing our connection to RabbitMQ, schedule another
    message to be delivered in PUBLISH_INTERVAL seconds.

    """
    if self._stopping:
      return
    LOGGER.info('Scheduling next message for %0.1f ms',
          self.PUBLISH_INTERVAL)
    self._connection.add_timeout(self.PUBLISH_INTERVAL,
                   self.publish_message)

  def start_publishing(self):
    """This method will enable delivery confirmations and schedule the
    first message to be sent to RabbitMQ

    """
    LOGGER.info('Issuing consumer related RPC commands')
    self.enable_delivery_confirmations()
    self.schedule_next_message()

  def on_bindok(self, unused_frame):
    """This method is invoked by pika when it receives the Queue.BindOk
    response from RabbitMQ. Since we know we're now setup and bound, it's
    time to start publishing."""
    LOGGER.info('Queue bound')
    self.start_publishing()

  def close_channel(self):
    """Invoke this command to close the channel with RabbitMQ by sending
    the Channel.Close RPC command.

    """
    LOGGER.info('Closing the channel')
    self._channel.close()

  def open_channel(self):
    """This method will open a new channel with RabbitMQ by issuing the
    Channel.Open RPC command. When RabbitMQ confirms the channel is open
    by sending the Channel.OpenOK RPC reply, the on_channel_open method
    will be invoked.

    """
    LOGGER.info('Creating a new channel')
    self._connection.channel(on_open_callback=self.on_channel_open)

# 需要导入模块: from pika.adapters.tornado_connection import TornadoConnection [as 别名]
# 或者: from pika.adapters.tornado_connection.TornadoConnection import add_timeout [as 别名]
class LoginPublish(object):

    def __init__(self):
        self.channel = None
        self.connection = None
        self.messages = []

    def initialcon(self):
        _logger.debug("pikapublish begin initialcon")
        credentials = pika.PlainCredentials('mxpub', 'mhearts2015')
        parameters =  pika.ConnectionParameters('localhost', 6500, credentials=credentials)
        self.connection = TornadoConnection(parameters, on_open_callback = self.on_connected)

    def on_connected(self, connection):
        _logger.debug("pikapublish begin on_connected")
        self.connection = connection
        self.connection.channel(self.on_channel_open)
        self.connection.add_on_close_callback(self.on_connection_closed)

    def on_connection_closed(self, connection, reply_code, reply_text):
        _logger.info("connection closed")
        self.connection.add_timeout(5, self.initialcon)

    def on_channel_open(self, channel):
        _logger.debug("pikapublish begin on_channel_open")
        self.channel = channel
        self.publishmsg()
        
    def releasecon(self):
        if self.connection:
            self.connection.close()

    def pushmsg(self, loginkey, body):
        _logger.debug("begin pushmsg %r  %s" % (body, loginkey))
        if not loginkey or not body:
            return

        self.messages.append({"key":loginkey, "body":body})
        self.publishmsg()

    def publishmsg(self):
        _logger.debug("begin to publishmsg")
        if not self.channel:
            _logger.debug("begin to open channel")
            self.initialcon()
            return

        for item in self.messages:
            key = item.get("key", "")
            body = item.get("body", "")

            _logger.info("begin to publish %s body = %r" % (key, body))
            if not isinstance(key, str) and not isinstance(key, bytes):
                _logger.error("invalid key")
                continue

            noti_body = json.dumps(body)
            try:
                self.channel.basic_publish(exchange = 'pclogin',
                                           routing_key = key,
                                           body = noti_body)
            except Exception as e:
                _logger.error("pikapublish  catch exception {0}".format(e))


        self.messages[:] = []