示例#1
0
    def consume(self,
                queue,
                consumer,
                consumer_tag='',
                no_local=False,
                no_ack=True,
                exclusive=False,
                nowait=True,
                ticket=None,
                cb=None):
        '''
    Start a queue consumer. If `cb` is supplied, will be called when
    broker confirms that consumer is registered.
    '''
        nowait = nowait and self.allow_nowait() and not cb

        if nowait and consumer_tag == '':
            consumer_tag = self._generate_consumer_tag()

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
          write_shortstr(queue).\
          write_shortstr(consumer_tag).\
          write_bits( no_local, no_ack, exclusive, nowait ).\
          write_table({}) # unused according to spec
        self.send_frame(MethodFrame(self.channel_id, 60, 20, args))

        if not nowait:
            self._pending_consumers.append((consumer, cb))
            self.channel.add_synchronous_cb(self._recv_consume_ok)
        else:
            self._consumer_cb[consumer_tag] = consumer
示例#2
0
    def declare(
        self,
        exchange,
        type,
        passive=False,
        durable=False,
        auto_delete=True,
        internal=False,
        nowait=True,
        arguments=None,
        ticket=None,
        cb=None,
    ):
        """
        Declare the exchange.

        exchange - The name of the exchange to declare
        type - One of
        """
        nowait = nowait and self.allow_nowait() and not cb

        args = Writer()
        args.write_short(ticket or self.default_ticket).write_shortstr(exchange).write_shortstr(type).write_bits(
            passive, durable, auto_delete, internal, nowait
        ).write_table(arguments or {})
        self.send_frame(MethodFrame(self.channel_id, 40, 10, args))

        if not nowait:
            self._declare_cb.append(cb)
            self.channel.add_synchronous_cb(self._recv_declare_ok)
示例#3
0
  def close(self, reply_code=0, reply_text='', class_id=0, method_id=0):
    '''
    Close this channel.  Caller has the option of specifying the reason for
    closure and the class and method ids of the current frame in which an error
    occurred.  If in the event of an exception, the channel will be marked
    as immediately closed.  If channel is already closed, call is ignored.
    '''
    if self._closed: return

    self._close_info = {
      'reply_code'    : reply_code,
      'reply_text'    : reply_text,
      'class_id'      : class_id,
      'method_id'     : method_id
    }

    # exception likely due to race condition as connection is closing
    try:
      args = Writer()
      args.write_short( reply_code )
      args.write_shortstr( reply_text )
      args.write_short( class_id )
      args.write_short( method_id )
      self.send_frame( MethodFrame(self.channel_id, 20, 40, args) )
      
      self.channel.add_synchronous_cb( self._recv_close_ok )
    except:
      self.logger.error("Failed to close channel %d", 
        self.channel_id, exc_info=True)

    # Immediately set the closed flag so that no more frames can be sent
    self._closed = True
示例#4
0
    def consume(self,
                queue,
                consumer,
                consumer_tag='',
                no_local=False,
                no_ack=True,
                exclusive=False,
                nowait=True,
                ticket=None):
        '''
    start a queue consumer.
    '''
        if nowait and consumer_tag == '':
            consumer_tag = self._generate_consumer_tag()

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
          write_shortstr(queue).\
          write_shortstr(consumer_tag).\
          write_bits( no_local, no_ack, exclusive, nowait ).\
          write_table({}) # unused according to spec
        self.send_frame(MethodFrame(self.channel_id, 60, 20, args))

        if not nowait:
            self.channel.add_synchronous_cb(self._recv_consume_ok)
            self._pending_consumers.append(consumer)
        else:
            self._consumer_cb[consumer_tag] = consumer
示例#5
0
    def nack(self, delivery_tag, multiple=False, requeue=False):
        '''Send a nack to the broker.'''
        args = Writer()
        args.write_longlong(delivery_tag).\
          write_bits(multiple, requeue)

        self.send_frame(MethodFrame(self.channel_id, 60, 120, args))
示例#6
0
    def declare(self,
                exchange,
                type,
                passive=False,
                durable=False,
                nowait=True,
                arguments=None,
                ticket=None,
                cb=None):
        """
        Declare the exchange.

        exchange - The name of the exchange to declare
        type - One of
        """
        nowait = nowait and self.allow_nowait() and not cb

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
            write_shortstr(exchange).\
            write_shortstr(type).\
            write_bits(passive, durable, False, False, nowait).\
            write_table(arguments or {})
        self.send_frame(MethodFrame(self.channel_id, 40, 10, args))

        if not nowait:
            self._declare_cb.append(cb)
            self.channel.add_synchronous_cb(self._recv_declare_ok)
示例#7
0
    def test_write_short_at(self):
        w = Writer(bytearray('\x00' * 6))
        assert_true(w is w.write_short_at(2**16 - 1, 2))
        assert_equals(bytearray('\x00\x00\xff\xff\x00\x00'), w._output_buffer)

        assert_raises(ValueError, w.write_short_at, -1, 2)
        assert_raises(ValueError, w.write_short_at, 2**16, 3)
示例#8
0
  def test_field_table(self):
    w = Writer()
    expect( w.write_table ).args( {'foo':'bar'} ).side_effect(
      lambda: w._output_buffer.extend('tdata') )
    w._field_table( {'foo':'bar'} )

    assert_equals( 'Ftdata', w._output_buffer )
示例#9
0
    def declare(self,
                queue='',
                passive=False,
                durable=False,
                exclusive=False,
                auto_delete=True,
                nowait=True,
                arguments={},
                ticket=None,
                cb=None):
        '''
    Declare a queue.  By default is asynchronoous but will be synchronous if nowait=False
    or a callback is defined. In synchronous mode, returns (message_count, consumer_count)

    queue - The name of the queue
    cb - An optional method which will be called with (queue_name, msg_count, consumer_count)
         if nowait=False
    '''
        nowait = nowait and self.allow_nowait() and not cb

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
          write_shortstr(queue).\
          write_bits(passive, durable, exclusive, auto_delete, nowait).\
          write_table(arguments)
        self.send_frame(MethodFrame(self.channel_id, 50, 10, args))

        if not nowait:
            self._declare_cb.append(cb)
            return self.channel.add_synchronous_cb(self._recv_declare_ok)
示例#10
0
    def bind(self,
             queue,
             exchange,
             routing_key='',
             nowait=True,
             arguments={},
             ticket=None,
             cb=None):
        '''
    bind to a queue.
    '''
        # If a callback is defined, then we have to use synchronous transactions.
        if cb: nowait = False

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
          write_shortstr(queue).\
          write_shortstr(exchange).\
          write_shortstr(routing_key).\
          write_bit(nowait).\
          write_table(arguments)
        self.send_frame(MethodFrame(self.channel_id, 50, 20, args))

        if not nowait:
            self.channel.add_synchronous_cb(self._recv_bind_ok)
            self._bind_cb.append(cb)
示例#11
0
    def test_write_short_at(self):
        w = Writer(bytearray("\x00" * 6))
        assert_true(w is w.write_short_at(2 ** 16 - 1, 2))
        assert_equals(bytearray("\x00\x00\xff\xff\x00\x00"), w._output_buffer)

        assert_raises(ValueError, w.write_short_at, -1, 2)
        assert_raises(ValueError, w.write_short_at, 2 ** 16, 3)
示例#12
0
  def cancel(self, consumer_tag='', nowait=True, consumer=None, cb=None):
    '''
    Cancel a consumer. Can choose to delete based on a consumer tag or the
    function which is consuming.  If deleting by function, take care to only
    use a consumer once per channel.
    '''
    if consumer:
      for (tag,func) in self._consumer_cb.iteritems():
        if func==consumer:
          consumer_tag = tag
          break

    nowait = nowait and self.allow_nowait() and not cb

    args = Writer()
    args.write_shortstr(consumer_tag).\
      write_bit(nowait)
    self.send_frame( MethodFrame(self.channel_id, 60, 30, args) )

    if not nowait:
      self._cancel_cb.append( cb )
      self.channel.add_synchronous_cb( self._recv_cancel_ok )
    else:
      try:
        del self._consumer_cb[consumer_tag]
      except KeyError:
        self.logger.warning( 'no callback registered for consumer tag " %s "', consumer_tag )
示例#13
0
    def test_field_table(self):
        w = Writer()
        expect(w.write_table).args({'foo': 'bar'}).side_effect(
            lambda *args: w._output_buffer.extend('tdata'))
        w._field_table({'foo': 'bar'})

        assert_equals('Ftdata', w._output_buffer)
示例#14
0
    def bind(self,
             queue,
             exchange,
             routing_key='',
             nowait=True,
             arguments={},
             ticket=None,
             cb=None):
        '''
    bind to a queue.
    '''
        nowait = nowait and self.allow_nowait() and not cb

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
          write_shortstr(queue).\
          write_shortstr(exchange).\
          write_shortstr(routing_key).\
          write_bit(nowait).\
          write_table(arguments)
        self.send_frame(MethodFrame(self.channel_id, 50, 20, args))

        if not nowait:
            self._bind_cb.append(cb)
            self.channel.add_synchronous_cb(self._recv_bind_ok)
示例#15
0
 def _send_close(self):
     args = Writer()
     args.write_short(self.connection._close_info['reply_code'])
     args.write_shortstr(self.connection._close_info['reply_text'][:255])
     args.write_short(self.connection._close_info['class_id'])
     args.write_short(self.connection._close_info['method_id'])
     self.send_frame(MethodFrame(self.channel_id, 10, 50, args))
示例#16
0
    def unbind(self,
               exchange,
               source,
               routing_key='',
               nowait=True,
               arguments={},
               ticket=None,
               cb=None):
        '''
    Unbind an exchange from another.
    '''
        nowait = nowait and self.allow_nowait() and not cb

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
          write_shortstr(exchange).\
          write_shortstr(source).\
          write_shortstr(routing_key).\
          write_bit(nowait).\
          write_table(arguments or {})
        self.send_frame(MethodFrame(self.channel_id, 40, 40, args))

        if not nowait:
            self._unbind_cb.append(cb)
            self.channel.add_synchronous_cb(self._recv_unbind_ok)
示例#17
0
    def close(self, reply_code=0, reply_text='', class_id=0, method_id=0):
        '''
    Close this channel.  Caller has the option of specifying the reason for
    closure and the class and method ids of the current frame in which an error
    occurred.  If in the event of an exception, the channel will be marked
    as immediately closed.  If channel is already closed, call is ignored.
    '''
        if not getattr(self, 'channel', None) or self.channel._closed: return

        self.channel._close_info = {
            'reply_code': reply_code,
            'reply_text': reply_text,
            'class_id': class_id,
            'method_id': method_id
        }

        # exceptions here likely due to race condition as connection is closing
        # cap the reply_text we send because it may be arbitrarily long
        try:
            args = Writer()
            args.write_short(reply_code)
            args.write_shortstr(reply_text[:255])
            args.write_short(class_id)
            args.write_short(method_id)
            self.send_frame(MethodFrame(self.channel_id, 20, 40, args))

            self.channel.add_synchronous_cb(self._recv_close_ok)
        finally:
            # Immediately set the closed flag so that no more frames can be sent
            # NOTE: in synchronous mode, by the time this is called we will have
            # already run self.channel._closed_cb and so the channel reference is
            # gone.
            if self.channel:
                self.channel._closed = True
示例#18
0
    def nack(self, delivery_tag, multiple=False, requeue=False):
        '''Send a nack to the broker.'''
        args = Writer()
        args.write_longlong(delivery_tag).\
            write_bits(multiple, requeue)

        self.send_frame(MethodFrame(self.channel_id, 60, 120, args))
示例#19
0
    def consume(self, queue, consumer, consumer_tag='',
                no_local=False, no_ack=True, exclusive=False,
                nowait=True, ticket=None, cb=None):
        '''
        Start a queue consumer. If `cb` is supplied, will be called when
        broker confirms that consumer is registered.
        '''
        nowait = nowait and self.allow_nowait() and not cb

        if nowait and consumer_tag == '':
            consumer_tag = self._generate_consumer_tag()

        args = Writer()
        args.write_short(ticket or self.default_ticket).\
            write_shortstr(queue).\
            write_shortstr(consumer_tag).\
            write_bits(no_local, no_ack, exclusive, nowait).\
            write_table({})  # unused according to spec
        self.send_frame(MethodFrame(self.channel_id, 60, 20, args))

        if not nowait:
            self._pending_consumers.append((consumer, cb))
            self.channel.add_synchronous_cb(self._recv_consume_ok)
        else:
            self._consumer_cb[consumer_tag] = consumer
示例#20
0
    def declare(
        self,
        queue="",
        passive=False,
        durable=False,
        exclusive=False,
        auto_delete=True,
        nowait=True,
        arguments={},
        ticket=None,
        cb=None,
    ):
        """
    Declare a queue.  By default is asynchronoous but will be synchronous if nowait=False
    or a callback is defined.

    queue - The name of the queue
    cb - An optional method which will be called with (queue_name, msg_count, consumer_count)
         if nowait=False
    """
        # If a callback is defined, then we have to use synchronous transactions.
        if cb:
            nowait = False

        args = Writer()
        args.write_short(ticket or self.default_ticket).write_shortstr(queue).write_bits(
            passive, durable, exclusive, auto_delete, nowait
        ).write_table(arguments)
        self.send_frame(MethodFrame(self.channel_id, 50, 10, args))

        if not nowait:
            self.channel.add_synchronous_cb(self._recv_declare_ok)
            self._declare_cb.append(cb)
示例#21
0
 def test_write_long_at(self):
   w = Writer( bytearray('\x00'*8) )
   assert_true( w is w.write_long_at(2**32-1,2) )
   assert_equals( bytearray('\x00\x00\xff\xff\xff\xff\x00\x00'), w._output_buffer )
   
   assert_raises( ValueError, w.write_long_at, -1, 2 )
   assert_raises( ValueError, w.write_long_at, 2**32, 3 )
示例#22
0
    def test_write_field_supports_subclasses(self):
        class SubString(str):
            pass

        w = Writer()
        w._write_field(SubString('foo'))
        assert_equals('S\x00\x00\x00\x03foo', w._output_buffer)
示例#23
0
 def test_write_long(self):
   w = Writer()
   assert_true( w is w.write_long(0) )
   assert_true( w is w.write_long(2**32-2) )
   assert_equals( bytearray('\x00\x00\x00\x00\xff\xff\xff\xfe'), w._output_buffer )
   
   assert_raises( ValueError, w.write_long, -1 )
   assert_raises( ValueError, w.write_long, 2**32 )
示例#24
0
 def _send_flow(self, active):
     '''
     Send a flow control command.
     '''
     args = Writer()
     args.write_bit(active)
     self.send_frame(MethodFrame(self.channel_id, 20, 20, args))
     self.channel.add_synchronous_cb(self._recv_flow_ok)
示例#25
0
  def test_write_short(self):
    w = Writer()
    assert_true( w is w.write_short(0) )
    assert_true( w is w.write_short(2**16-2) )
    assert_equals( bytearray('\x00\x00\xff\xfe'), w._output_buffer )

    assert_raises( ValueError, w.write_short, -1 )
    assert_raises( ValueError, w.write_short, 2**16 )
示例#26
0
  def test_write_octet(self):
    w = Writer()
    assert_true( w is w.write_octet(0) )
    assert_true( w is w.write_octet(255) )
    assert_equals( bytearray('\x00\xff'), w._output_buffer )

    assert_raises( ValueError, w.write_octet, -1 )
    assert_raises( ValueError, w.write_octet, 2**8 )
示例#27
0
 def open(self):
     '''
     Open the channel for communication.
     '''
     args = Writer()
     args.write_shortstr('')
     self.send_frame(MethodFrame(self.channel_id, 20, 10, args))
     self.channel.add_synchronous_cb(self._recv_open_ok)
示例#28
0
    def test_write_short(self):
        w = Writer()
        assert_true(w is w.write_short(0))
        assert_true(w is w.write_short(2**16 - 2))
        assert_equals(bytearray('\x00\x00\xff\xfe'), w._output_buffer)

        assert_raises(ValueError, w.write_short, -1)
        assert_raises(ValueError, w.write_short, 2**16)
示例#29
0
 def _send_start_ok(self):
     '''Send the start_ok message.'''
     args = Writer()
     args.write_table(self.connection._properties)
     args.write_shortstr(self.connection._login_method)
     args.write_longstr(self.connection._login_response)
     args.write_shortstr(self.connection._locale)
     self.send_frame(MethodFrame(self.channel_id, 10, 11, args))
示例#30
0
    def test_write_octet(self):
        w = Writer()
        assert_true(w is w.write_octet(0))
        assert_true(w is w.write_octet(255))
        assert_equals(bytearray('\x00\xff'), w._output_buffer)

        assert_raises(ValueError, w.write_octet, -1)
        assert_raises(ValueError, w.write_octet, 2**8)
示例#31
0
  def reject(self, delivery_tag, requeue=False):
    '''
    Reject a message.
    '''
    args = Writer()
    args.write_longlong( delivery_tag ).\
      write_bit( requeue )

    self.send_frame( MethodFrame(self.channel_id, 60, 90, args) )
示例#32
0
 def test_write_field(self):
   w = Writer()
   unknown = mock()
   expect( w._field_none ).args( unknown )
   w._write_field( unknown )
   
   Writer.field_type_map[type(unknown)] = unknown
   expect( unknown ).args( w, unknown )
   w._write_field( unknown )
示例#33
0
  def test_write_bits(self):
    w = Writer()
    assert_true( w is w.write_bits(False,True) )
    assert_equals( bytearray('\x02'), w._output_buffer )
    w = Writer()
    assert_true( w is w.write_bits(False,False,True,True,True) )
    assert_equals( bytearray('\x1c'), w._output_buffer )

    assert_raises( ValueError, w.write_bits, *((True,)*9) )
示例#34
0
    def test_write_long(self):
        w = Writer()
        assert_true(w is w.write_long(0))
        assert_true(w is w.write_long(2**32 - 2))
        assert_equals(bytearray('\x00\x00\x00\x00\xff\xff\xff\xfe'),
                      w._output_buffer)

        assert_raises(ValueError, w.write_long, -1)
        assert_raises(ValueError, w.write_long, 2**32)
示例#35
0
  def test_write_table(self):
    w = Writer()
    expect( w._write_item ).args( 'a', 'foo' ).any_order().side_effect( 
      lambda: (setattr(w,'_pos',20), w._output_buffer.extend('afoo')) )
    expect( w._write_item ).args( 'b', 'bar' ).any_order().side_effect( 
      lambda: (setattr(w,'_pos',20), w._output_buffer.extend('bbar')) )

    assert_true( w is w.write_table({'a':'foo','b':'bar'}) )
    assert_equals( '\x00\x00\x00\x08', w._output_buffer[:4] )
    assert_equals( 12, len(w._output_buffer) )
示例#36
0
  def recover_async(self, requeue=False):
    '''
    Redeliver all unacknowledged messaages on this channel.

    This method is deprecated in favour of the synchronous recover/recover-ok
    '''
    args = Writer()
    args.write_bit( requeue )

    self.send_frame( MethodFrame(self.channel_id, 60, 100, args) )
示例#37
0
  def ack(self, delivery_tag, multiple=False):
    '''
    Acknowledge delivery of a message.  If multiple=True, acknowledge up-to
    and including delivery_tag.
    '''
    args = Writer()
    args.write_longlong(delivery_tag).\
      write_bit(multiple)

    self.send_frame( MethodFrame(self.channel_id, 60, 80, args) )
示例#38
0
 def test_return_msg(self):
     args = Writer()
     args.write_short(3)
     args.write_shortstr('reply_text')
     args.write_shortstr('exchange')
     args.write_shortstr('routing_key')
     expect(mock(basic_class, 'MethodFrame')).args(42, 60, 50,
                                                   args).returns('frame')
     expect(self.klass.send_frame).args('frame')
     self.klass.return_msg(3, 'reply_text', 'exchange', 'routing_key')
示例#39
0
    def test_write_table(self):
        w = Writer()
        expect(w._write_item).args('a', 'foo').any_order().side_effect(
            lambda *args: (setattr(w, '_pos', 20), w._output_buffer.extend('afoo')))
        expect(w._write_item).args('b', 'bar').any_order().side_effect(
            lambda *args: (setattr(w, '_pos', 20), w._output_buffer.extend('bbar')))

        assert_true(w is w.write_table({'a': 'foo', 'b': 'bar'}))
        assert_equals('\x00\x00\x00\x08', w._output_buffer[:4])
        assert_equals(12, len(w._output_buffer))
示例#40
0
 def _send_close(self):
   args = Writer()
   args.write_short( self.connection._close_info['reply_code'] )
   args.write_shortstr( self.connection._close_info['reply_text'][:255] )
   args.write_short( self.connection._close_info['class_id'] )
   args.write_short( self.connection._close_info['method_id'] )
   self.send_frame( MethodFrame(self.channel_id, 10, 50, args) )
示例#41
0
  def close(self, reply_code=0, reply_text='', class_id=0, method_id=0):
    '''
    Close this channel.  Caller has the option of specifying the reason for
    closure and the class and method ids of the current frame in which an error
    occurred.  If in the event of an exception, the channel will be marked
    as immediately closed.  If channel is already closed, call is ignored.
    '''
    if not getattr(self, 'channel', None) or self.channel._closed: return

    self.channel._close_info = {
      'reply_code'    : reply_code,
      'reply_text'    : reply_text,
      'class_id'      : class_id,
      'method_id'     : method_id
    }

    # exceptions here likely due to race condition as connection is closing
    # cap the reply_text we send because it may be arbitrarily long
    try:
      args = Writer()
      args.write_short( reply_code )
      args.write_shortstr( reply_text[:255] )
      args.write_short( class_id )
      args.write_short( method_id )
      self.send_frame( MethodFrame(self.channel_id, 20, 40, args) )

      self.channel.add_synchronous_cb( self._recv_close_ok )
    finally:
      # Immediately set the closed flag so that no more frames can be sent
      # NOTE: in synchronous mode, by the time this is called we will have
      # already run self.channel._closed_cb and so the channel reference is
      # gone.
      if self.channel:
        self.channel._closed = True
示例#42
0
  def close(self, reply_code=0, reply_text='', class_id=0, method_id=0):
    '''
    Close this channel.  Caller has the option of specifying the reason for
    closure and the class and method ids of the current frame in which an error
    occurred.  If in the event of an exception, the channel will be marked
    as immediately closed.  If channel is already closed, call is ignored.
    '''
    if self._closed: return

    self._close_info = {
      'reply_code'    : reply_code,
      'reply_text'    : reply_text,
      'class_id'      : class_id,
      'method_id'     : method_id
    }

    try:
      args = Writer()
      args.write_short( reply_code )
      args.write_shortstr( reply_text )
      args.write_short( class_id )
      args.write_short( method_id )
      self.send_frame( MethodFrame(self.channel_id, 20, 40, args) )
      
      self.channel.add_synchronous_cb( self._recv_close_ok )
    except:
      self.logger.error("Failed to close channel %d", 
        self.channel_id, exc_info=True)

    # Immediately set the closed flag so that no more frames can be sent
    self._closed = True
示例#43
0
  def qos(self, prefetch_size=0, prefetch_count=0, is_global=False):
    '''
    Set QoS on this channel.
    '''
    args = Writer()
    args.write_long(prefetch_size).\
      write_short(prefetch_count).\
      write_bit(is_global)
    self.send_frame( MethodFrame(self.channel_id, 60, 10, args) )

    self.channel.add_synchronous_cb( self._recv_qos_ok )
示例#44
0
  def write_frame(self, buf):
    '''
    Write the frame into an existing buffer.
    '''
    writer = Writer( buf )

    writer.write_octet( self.type() ).\
      write_short(self.channel_id).\
      write_long( len(self._payload) ).\
      write( self._payload ).\
      write_octet( 0xce )
示例#45
0
    def _send_tune_ok(self):
        args = Writer()
        args.write_short(self.connection._channel_max)
        args.write_long(self.connection._frame_max)

        if self.connection._heartbeat:
            args.write_short(self.connection._heartbeat)
        else:
            args.write_short(0)

        self.send_frame(MethodFrame(self.channel_id, 10, 31, args))
示例#46
0
 def _send_start_ok(self):
   '''Send the start_ok message.'''
   args = Writer()
   args.write_table(self.connection._properties)
   args.write_shortstr(self.connection._login_method)
   args.write_longstr(self.connection._login_response)
   args.write_shortstr(self.connection._locale)
   self.send_frame( MethodFrame(self.channel_id, 10, 11, args) )
示例#47
0
    def _recv_flow(self, method_frame):
        '''
        Receive a flow control command from the broker
        '''
        self.channel._active = method_frame.args.read_bit()

        args = Writer()
        args.write_bit(self.channel.active)
        self.send_frame(MethodFrame(self.channel_id, 20, 21, args))

        if self._flow_control_cb is not None:
            self._flow_control_cb()
示例#48
0
    def unbind(self, queue, exchange, routing_key="", arguments={}, ticket=None, cb=None):
        """
    Unbind a queue from an exchange.  This is always synchronous.
    """
        args = Writer()
        args.write_short(ticket or self.default_ticket).write_shortstr(queue).write_shortstr(exchange).write_shortstr(
            routing_key
        ).write_table(arguments)
        self.send_frame(MethodFrame(self.channel_id, 50, 50, args))

        self.channel.add_synchronous_cb(self._recv_unbind_ok)
        self._unbind_cb.append(cb)
示例#49
0
    def test_write_table(self):
        w = Writer()
        expect(w._write_item).args("a", "foo").any_order().side_effect(
            lambda: (setattr(w, "_pos", 20), w._output_buffer.extend("afoo"))
        )
        expect(w._write_item).args("b", "bar").any_order().side_effect(
            lambda: (setattr(w, "_pos", 20), w._output_buffer.extend("bbar"))
        )

        assert_true(w is w.write_table({"a": "foo", "b": "bar"}))
        assert_equals("\x00\x00\x00\x08", w._output_buffer[:4])
        assert_equals(12, len(w._output_buffer))
示例#50
0
  def return_msg(self, reply_code, reply_text, exchange, routing_key):
    '''
    Return a failed message.  Not named "return" because python interpreter
    can't deal with that.
    '''
    args = Writer()
    args.write_short( reply_code ).\
      write_shortstr( reply_text ).\
      write_shortstr( exchange ).\
      write_shortstr( routing_key )

    self.send_frame( MethodFrame(self.channel_id, 60, 50, args) )
示例#51
0
  def recover(self, requeue=False, cb=None):
    '''
    Ask server to redeliver all unacknowledged messages.
    '''
    args = Writer()
    args.write_bit( requeue )

    # The XML spec is incorrect; this method is always synchronous
    #  http://lists.rabbitmq.com/pipermail/rabbitmq-discuss/2011-January/010738.html
    self._recover_cb.append( cb )
    self.send_frame( MethodFrame(self.channel_id, 60, 110, args) )
    self.channel.add_synchronous_cb( self._recv_recover_ok )