def delete(self, queue, if_unused=False, if_empty=False, nowait=True, ticket=None, cb=None): ''' queue delete. ''' nowait = nowait and self.allow_nowait() and not cb args = Writer() args.write_short(ticket or self.default_ticket).\ write_shortstr(queue).\ write_bits(if_unused, if_empty, nowait) self.send_frame( MethodFrame(self.channel_id, 50, 40, args) ) if not nowait: self._delete_cb.append( cb ) return self.channel.add_synchronous_cb( self._recv_delete_ok )
def purge(self, queue, nowait=True, ticket=None, cb=None): ''' Purge all messages in 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_bit(nowait) self.send_frame(MethodFrame(self.channel_id, 50, 30, args)) if not nowait: self.channel.add_synchronous_cb(self._recv_purge_ok) self._purge_cb.append(cb)
def delete(self, exchange, if_unused=False, nowait=True, ticket=None, cb=None): ''' Delete an exchange. ''' # 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(exchange).\ write_bits(if_unused, nowait) self.send_frame( MethodFrame(self.channel_id, 40, 20, args) ) if not nowait: self.channel.add_synchronous_cb( self._recv_delete_ok ) self._delete_cb.append( cb )
def select(self, nowait=True, cb=None): ''' Set this channel to use publisher confirmations. ''' nowait = nowait and self.allow_nowait() and not cb if not self._enabled: self._enabled = True self.channel.basic._msg_id = 0 self.channel.basic._last_ack_id = 0 args = Writer() args.write_bit(nowait) self.send_frame(MethodFrame(self.channel_id, 85, 10, args)) if not nowait: self._select_cb.append(cb) self.channel.add_synchronous_cb(self._recv_select_ok)
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 )
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._unbind_cb.append(cb) self.channel.add_synchronous_cb(self._recv_unbind_ok)
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 )
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 """ # 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(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.channel.add_synchronous_cb( self._recv_declare_ok ) self._declare_cb.append( cb )
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
def publish(self, msg, exchange, routing_key, mandatory=False, immediate=False, ticket=None): ''' publish a message. ''' args = Writer() args.write_short(ticket or self.default_ticket).\ write_shortstr(exchange).\ write_shortstr(routing_key).\ write_bits(mandatory, immediate) self.send_frame(MethodFrame(self.channel_id, 60, 40, args)) self.send_frame( HeaderFrame(self.channel_id, 60, 0, len(msg), msg.properties)) frame_max = self.channel.connection.frame_max for frame in ContentFrame.create_frames(self.channel_id, msg.body, frame_max): self.send_frame(frame)