def test_consume(self):
global count
conn = Connection('localhost', io_loop=self.io_loop)
test_msg = Message('test')
count = 0
def clean_up():
assert not ch.consumers
conn.close(self.stop)
def consume_callback(msg):
global ch, count, consumer
count += 1
assert msg.body == 'test'
if count == 50:
consumer.cancel(clean_up)
def on_connect():
global ch, consumer
ch = conn.channel()
ch.exchange_declare('test_exchange', durable=False)
ch.queue_declare('test_queue', durable=False)
ch.queue_bind('test_queue', 'test_exchange', 'test')
for _ in xrange(50):
ch.publish(test_msg, exchange='test_exchange',
routing_key='test')
consumer = Consumer(consume_callback)
ch.consume('test_queue', consumer, no_ack=True)
conn.connect(on_connect)
self.wait()
def test_get(self):
conn = Connection('localhost', io_loop=self.io_loop)
ch = None
test_msg = Message('test')
def on_msg(msg):
global ch
assert msg.body == 'test'
msg.ack()
ch.get('test_queue', on_missing_msg)
def on_missing_msg(msg):
assert msg is None
conn.close(self.stop)
def on_connect():
global ch
ch = conn.channel()
ch.exchange_declare('test_exchange', durable=False)
ch.queue_delete('test_queue')
ch.queue_declare('test_queue', durable=False)
ch.queue_bind('test_queue', 'test_exchange', 'test')
ch.publish(test_msg, exchange='test_exchange', routing_key='test')
ch.get('test_queue', on_msg)
conn.connect(on_connect)
self.wait()
class RabbitMQ_Queue(object):
def _start_new_connect(self):
self.conn=Connection(self.Queue_Server,username=self.Queue_User,password=self.Queue_PassWord
,vhost=self.Queue_Path,port=self.Queue_Port, io_loop=tornado.ioloop.IOLoop.instance())
self.conn.on_disconnect=self.on_queue_disconnect
self.conn.on_error=self.on_queue_error
self.conn.connect(self.on_connect)
def __init__(self,Queue_Server,Queue_User,Queue_PassWord,Queue_Path,BackQueueName,Queue_Port=None):
self.Queue_Server=Queue_Server
self.Queue_User=Queue_User
self.Queue_PassWord=Queue_PassWord
self.Queue_Path=Queue_Path
self.Queue_Port=Queue_Port
self.back_queue="WSBack-"+BackQueueName
self._start_new_connect()
def on_connect(self):
if self.conn.status!=status.OPENED:
print 'connect rabbitmq fail'
self.conn.close(self.stop)
else:
print 'connect rabbitmq success'
self.channel = self.conn.channel()
self.channel.queue_declare('task', durable=True,
callback=self.on_queue_creation)
self.channel.queue_declare(self.back_queue,auto_delete=True,callback=self.on_queue_back_created,durable=False)
def on_queue_creation(self,qinfo):
print "queue %s created"%qinfo.queue
self.task_queue=qinfo.queue
def on_queue_back_created(self,qinfo):
print "back queue %s created"%qinfo.queue
self.back_queue=qinfo.queue
consumer = Consumer(self.consume_callback)
self.channel.consume(qinfo.queue, consumer, no_ack=True)
def consume_callback(self,msg):
connid=msg.headers.get("connid",None)
if connid:
conn=connection_list.get(connid,None)
if conn:
if int(msg.headers.get("close_connect",0)):
connection_list.pop(conn.connid,'')
conn.close()
conn.on_close()
return
retbody=msg.body
compressed=msg.headers.get('compression')=='application/x-gzip'
if compressed and not conn.usezlib:
retbody=zlib.decompress(retbody)
elif not compressed and conn.usezlib:
retbody=zlib.compress(retbody)
conn.write_message(retbody,binary=conn.usezlib)
conn.last_act_time=time.time()
def on_queue_disconnect(self):
time.sleep(5)
self._start_new_connect()
def on_queue_error(self,err):
print str(err)
time.sleep(5)
self._start_new_connect()
def publish(self,msg):
self.channel.publish(msg,'',self.task_queue)
def test_consume(self):
global count
conn = Connection('localhost', io_loop=self.io_loop)
test_msg = Message('test')
count = 0
def clean_up():
assert not ch.consumers
conn.close(self.stop)
def consume_callback(msg):
global ch, count, consumer
count += 1
assert msg.body == 'test', msg.body
if count == 50:
consumer.cancel(clean_up)
def on_connect():
global ch, consumer
ch = conn.channel()
ch.exchange_declare('test_exchange', durable=False)
ch.queue_delete('test_queue')
ch.queue_declare('test_queue', durable=False)
ch.queue_bind('test_queue', 'test_exchange', 'test')
for _ in xrange(50):
ch.publish(test_msg,
exchange='test_exchange',
routing_key='test')
consumer = Consumer(consume_callback)
ch.consume('test_queue', consumer, no_ack=True)
conn.connect(on_connect)
self.wait()
def test_get(self):
conn = Connection('localhost', io_loop=self.io_loop)
ch = None
test_msg = Message('test')
def on_msg(msg):
global ch
assert msg.body == 'test'
msg.ack()
ch.get('test_queue', on_missing_msg)
def on_missing_msg(msg):
assert msg is None
conn.close(self.stop)
def on_connect():
global ch
ch = conn.channel()
ch.exchange_declare('test_exchange', durable=False)
ch.queue_declare('test_queue', durable=False)
ch.queue_bind('test_queue', 'test_exchange', 'test')
ch.publish(test_msg, exchange='test_exchange', routing_key='test')
ch.get('test_queue', on_msg)
conn.connect(on_connect)
self.wait()
def test_handshake(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.assertEquals(conn.status, status.OPENED)
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_heartbeat(self):
conn = Connection('localhost', heartbeat=1, io_loop=self.io_loop)
def clean_up():
conn.status == status.OPENED
conn.close(self.stop)
conn.connect(lambda: None)
self.io_loop.add_timeout(time.time() + 4, clean_up)
self.wait()
def _start_new_connect(self):
self.conn = Connection(self.Queue_Server,
username=self.Queue_User,
password=self.Queue_PassWord,
vhost=self.Queue_Path,
port=self.Queue_Port,
io_loop=tornado.ioloop.IOLoop.instance())
self.conn.on_disconnect = self.on_queue_disconnect
self.conn.on_error = self.on_queue_error
self.conn.connect(self.on_connect)
def test_open(self):
conn = Connection('localhost', io_loop=self.io_loop)
def clean_up(**kargs):
conn.close(self.stop)
def on_connect():
ch = conn.channel(callback=clean_up)
conn.connect(on_connect)
self.wait()
def test_open(self):
conn = Connection('localhost', io_loop=self.io_loop)
def clean_up(**kargs):
conn.close(self.stop)
def on_connect():
ch = conn.channel(callback=clean_up)
conn.connect(on_connect)
self.wait()
def test_publish(self):
conn = Connection('localhost', io_loop=self.io_loop)
test_msg = Message('test')
def on_connect():
ch = conn.channel()
ch.exchange_declare('test_exchange', durable=False)
ch.publish(test_msg, exchange='test_exchange', routing_key='test')
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_publish(self):
conn = Connection('localhost', io_loop=self.io_loop)
test_msg = Message('test')
def on_connect():
ch = conn.channel()
ch.exchange_declare('test_exchange', durable=False)
ch.publish(test_msg, exchange='test_exchange', routing_key='test')
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
class RabbitMQ_Queue(object):
def _start_new_connect(self):
self.conn=Connection(self.Queue_Server,username=self.Queue_User,password=self.Queue_PassWord
,vhost=self.Queue_Path,port=self.Queue_Port, io_loop=tornado.ioloop.IOLoop.instance())
self.conn.on_disconnect=self.on_queue_disconnect
self.conn.on_error=self.on_queue_error
self.conn.connect(self.on_connect)
def __init__(self,Queue_Server,Queue_User,Queue_PassWord,Queue_Path,BackQueueName,Queue_Port=None):
self.Queue_Server=Queue_Server
self.Queue_User=Queue_User
self.Queue_PassWord=Queue_PassWord
self.Queue_Path=Queue_Path
self.Queue_Port=Queue_Port
self._start_new_connect()
def on_connect(self):
if self.conn.status!=status.OPENED:
print 'connect rabbitmq fail'
self.conn.close(self.stop)
else:
print 'connect rabbitmq success'
self.channel = self.conn.channel()
self.channel.queue_declare(auto_delete=True,callback=self.on_queue_back_created,durable=False)
def on_queue_back_created(self,qinfo):
print "back queue %s created"%qinfo.queue
self.back_queue=qinfo.queue
self.channel.queue_bind(self.back_queue,"sys.sms",routing_key='sms.code',callback=self.on_queue_binded)
consumer = Consumer(self.consume_callback)
self.channel.consume(self.back_queue, consumer, no_ack=True)
def on_queue_binded(self):
print "queue binded"
def consume_callback(self,msg):
compressed=msg.headers.get('compression')=='application/x-gzip'
if compressed:
retbody=zlib.decompress(msg.body)
else:
retbody=msg.body
global phone_pre
js_data=json.loads(retbody)
#if js_data['phone'][0:3] in phone_pre:
if True:
global connection_client
if connection_client:
connection_client.write_message(retbody)
def on_queue_disconnect(self):
time.sleep(5)
self._start_new_connect()
def on_queue_error(self,err):
time.sleep(5)
self._start_new_connect()
def publish(self,msg):
self.channel.publish(msg,'',self.task_queue)
def test_channel_flow(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.flow(active=False, callback=cleanup)
def cleanup():
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_channel_flow(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.flow(active=False, callback=cleanup)
def cleanup():
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_reliable_publishing(self):
test_msg = Message('test')
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
ch = conn.channel()
ch.exchange_declare('test_imm', durable=False)
ch.on_error = lambda: None
ch.select()
ch.publish(test_msg, exchange='test_imm')
ch.commit(lambda: conn.close(self.stop))
conn.connect(on_connect)
self.wait()
def test_reliable_publishing(self):
test_msg = Message('test')
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
ch = conn.channel()
ch.exchange_declare('test_imm', durable=False)
ch.on_error = lambda: None
ch.select()
ch.publish(test_msg, exchange='test_imm')
ch.commit(lambda: conn.close(self.stop))
conn.connect(on_connect)
self.wait()
def test_conn_error(self):
conn = Connection('localhost', io_loop=self.io_loop)
def send_wrong_method():
tune = Tune(frame_max=0, channel_max=0, heartbeat=0)
conn.send_method(tune, callback=done)
def done(conn_error):
assert conn_error.method == Tune, repr(conn_error.method)
assert conn_error.reply_code == 'CHANNEL_ERROR'
assert conn.status == status.CLOSED
self.stop()
conn.on_error = done
conn.connect(send_wrong_method)
self.wait()
def test_queue(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_creation(qinfo):
assert qinfo.queue == 'test_queue'
assert qinfo.message_count == 0
assert qinfo.consumer_count == 0
def on_connect():
ch = conn.channel()
ch.queue_delete('test_queue')
ch.queue_declare('test_queue', durable=False, callback=on_creation)
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_channel_error(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.on_error = on_error
self.ch.queue_bind('foo', 'bar')
def on_error(ch_error):
assert ch_error.method == queue.Bind, ch_error.method
assert ch_error.reply_code == 'NOT_FOUND'
assert self.ch.status == status.CLOSED
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_queue(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_creation(qinfo):
assert qinfo.queue == 'test_queue'
assert qinfo.message_count == 0
assert qinfo.consumer_count == 0
def on_connect():
ch = conn.channel()
ch.queue_delete('test_queue')
ch.queue_declare('test_queue', durable=False,
callback=on_creation)
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_heartbeat_server_disconnected(self):
conn = Connection('localhost', io_loop=self.io_loop)
def clean_up():
conn.status == status.CLOSED
self.stop()
conn.on_disconnect = clean_up
def launch_heartbeat():
conn.heartbeat = 1
HeartbeatMonitor(conn).start()
conn.connect(launch_heartbeat)
self.io_loop.add_timeout(time.time() + 3, clean_up)
self.wait()
def test_channel_error(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.on_error = on_error
self.ch.queue_bind('foo', 'bar')
def on_error(ch_error):
assert ch_error.method == queue.Bind, ch_error.method
assert ch_error.reply_code == 'NOT_FOUND'
assert self.ch.status == status.CLOSED
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_basic_return(self):
test_msg = Message('test')
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
ch = conn.channel()
ch.on_return = on_return
ch.exchange_declare('test_imm', durable=False)
ch.publish(test_msg, exchange='test_imm', immediate=True)
def on_return(msg):
rx = msg.rx_data
assert rx.reply_code == 313, rx.reply_code # NO_CONSUMERS
assert rx.exchange == 'test_imm', rx.exchange_declare
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_basic_return(self):
test_msg = Message('test')
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
ch = conn.channel()
ch.on_return = on_return
ch.exchange_declare('test_mand', durable=False)
ch.publish(test_msg, exchange='test_mand', mandatory=True)
def on_return(msg):
rx = msg.rx_data
assert rx.reply_code == 312, rx.reply_code # NO_ROUTE
assert rx.exchange == 'test_mand', rx.exchange_declare
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_nack(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.exchange_declare('test_exchange', durable=False)
self.ch.queue_delete('test_queue')
self.ch.queue_declare('test_queue', durable=True)
self.ch.qos(prefetch_count=49)
self.ch.queue_bind('test_queue', 'test_exchange', 'test')
for i in xrange(50):
msg = Message('test %d' % i)
self.ch.publish(msg,
exchange='test_exchange',
routing_key='test')
consumer = Consumer(consume_callback)
self.ch.consume('test_queue', consumer, no_ack=False)
def consume_callback(msg):
if msg.body == 'test 20':
msg.ack()
if msg.body == 'test 49':
msg.nack(multiple=True)
self.ch.close()
on_channel_closed()
msgs = []
def on_channel_closed():
self.ch2 = conn.channel()
for i in xrange(49):
self.ch2.get('test_queue', lambda msg: msgs.append(msg))
self.ch2.get('test_queue', check_and_clean_up)
def check_and_clean_up(msg):
msgs.append(msg)
good_msgs = [m for m in msgs if m is not None]
assert len(good_msgs) == 49, len(good_msgs)
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_purge_queue(self):
test_msg = Message('test')
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.queue_declare('test_purge_queue', auto_delete=True)
self.ch.exchange_declare('test_purge_exchange', durable=False)
self.ch.queue_bind(queue='test_purge_queue',
exchange='test_purge_exchange')
self.ch.queue_purge('test_purge_queue')
for _ in xrange(3):
self.ch.publish(test_msg, exchange='test_purge_exchange')
self.ch.queue_purge('test_purge_queue', purged)
def purged(msg_count):
assert msg_count==3, msg_count
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_queue_unbind(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.queue_delete('test_unbind_queue')
self.ch.queue_declare('test_unbind_queue', auto_delete=True)
self.ch.exchange_declare('test_unbind_exchange', durable=False)
self.ch.queue_bind(queue='test_unbind_queue',
exchange='test_unbind_exchange',
callback=on_binded)
def on_binded():
self.ch.queue_unbind(queue='test_unbind_queue',
exchange='test_unbind_exchange',
callback=on_unbinded)
def on_unbinded():
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_purge_queue(self):
test_msg = Message('test')
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel()
self.ch.queue_delete('test_queue')
self.ch.queue_declare('test_purge_queue', auto_delete=True)
self.ch.exchange_declare('test_purge_exchange', durable=False)
self.ch.queue_bind(queue='test_purge_queue',
exchange='test_purge_exchange')
self.ch.queue_purge('test_purge_queue')
for _ in xrange(3):
self.ch.publish(test_msg, exchange='test_purge_exchange')
self.ch.queue_purge('test_purge_queue', purged)
def purged(msg_count):
assert msg_count == 3, msg_count
conn.close(self.stop)
conn.connect(on_connect)
self.wait()
def test_channel_id_rollover(self):
global count
conn = Connection('localhost', io_loop=self.io_loop)
count = 0
def next_channel():
global count
count += 1
self.ch = conn.channel()
if (count < 70000):
self.ch.close(callback=next_channel)
else:
self.ch.close(callback=cleanup)
def on_connect():
next_channel()
def cleanup():
conn.close(self.stop)
conn.connect(on_connect)
self.wait(timeout=300)
def test_publish_huge(self):
conn = Connection('localhost', io_loop=self.io_loop)
msg = "test message" * 151343
test_msg = Message(msg)
def on_connect():
ch = conn.channel()
def callback(msg):
conn.close(self.stop)
def on_creation(q):
ch.publish(test_msg,
exchange='test_exchange',
routing_key='test')
ch.consume(q.queue, callback)
ch.exchange_declare('test_exchange', durable=False)
ch.queue_delete('test_queue')
ch.queue_declare('test_queue', durable=False, callback=on_creation)
ch.queue_bind('test_queue', 'test_exchange', 'test')
conn.connect(on_connect)
self.wait(timeout=1)
def test_channel_id_rollover(self):
global count
conn = Connection('localhost', io_loop=self.io_loop)
count = 0
def next_channel():
global count
count += 1
self.ch = conn.channel()
if (count < 70000):
self.ch.close(callback=next_channel)
else:
self.ch.close(callback=cleanup)
def on_connect():
next_channel()
def cleanup():
conn.close(self.stop)
conn.connect(on_connect)
self.wait(timeout=300)
def test_close(self):
conn = Connection('localhost', io_loop=self.io_loop)
def on_connect():
self.ch = conn.channel(callback=on_channel)
def on_channel():
self.ch.close(when_channel_close)
def when_channel_close():
try:
self.ch.get('foo', callback=lambda msg: None)
except AmqpStatusError, e:
clean_up()
else:
class RabbitMQ_Queue(object):
def _start_new_connect(self):
self.conn = Connection(self.Queue_Server,
username=self.Queue_User,
password=self.Queue_PassWord,
vhost=self.Queue_Path,
port=self.Queue_Port,
io_loop=tornado.ioloop.IOLoop.instance())
self.conn.on_disconnect = self.on_queue_disconnect
self.conn.on_error = self.on_queue_error
self.conn.connect(self.on_connect)
def __init__(self,
Queue_Server,
Queue_User,
Queue_PassWord,
Queue_Path,
BackQueueName,
Queue_Port=None):
self.Queue_Server = Queue_Server
self.Queue_User = Queue_User
self.Queue_PassWord = Queue_PassWord
self.Queue_Path = Queue_Path
self.Queue_Port = Queue_Port
self.back_queue = "WSBack-" + BackQueueName
self._start_new_connect()
def on_connect(self):
if self.conn.status != status.OPENED:
print 'connect rabbitmq fail'
self.conn.close(self.stop)
else:
print 'connect rabbitmq success'
self.channel = self.conn.channel()
self.channel.queue_declare('task',
durable=True,
callback=self.on_queue_creation)
self.channel.queue_declare(self.back_queue,
auto_delete=True,
callback=self.on_queue_back_created,
durable=False)
def on_queue_creation(self, qinfo):
print "queue %s created" % qinfo.queue
self.task_queue = qinfo.queue
def on_queue_back_created(self, qinfo):
print "back queue %s created" % qinfo.queue
self.back_queue = qinfo.queue
consumer = Consumer(self.consume_callback)
self.channel.consume(qinfo.queue, consumer, no_ack=True)
def consume_callback(self, msg):
connid = msg.headers.get("connid", None)
if connid:
conn = connection_list.get(connid, None)
if conn:
if int(msg.headers.get("close_connect", 0)):
connection_list.pop(conn.connid, '')
conn.close()
conn.on_close()
return
retbody = msg.body
compressed = msg.headers.get(
'compression') == 'application/x-gzip'
if compressed and not conn.usezlib:
retbody = zlib.decompress(retbody)
elif not compressed and conn.usezlib:
retbody = zlib.compress(retbody)
conn.write_message(retbody, binary=conn.usezlib)
conn.last_act_time = time.time()
def on_queue_disconnect(self):
time.sleep(5)
self._start_new_connect()
def on_queue_error(self, err):
print str(err)
time.sleep(5)
self._start_new_connect()
def publish(self, msg):
self.channel.publish(msg, '', self.task_queue)
def _start_new_connect(self):
self.conn=Connection(self.Queue_Server,username=self.Queue_User,password=self.Queue_PassWord
,vhost=self.Queue_Path,port=self.Queue_Port, io_loop=tornado.ioloop.IOLoop.instance())
self.conn.on_disconnect=self.on_queue_disconnect
self.conn.on_error=self.on_queue_error
self.conn.connect(self.on_connect)
def test_heartbeat_client_disconnected(self):
conn = Connection('localhost', heartbeat=1, io_loop=self.io_loop)
conn.process_heartbeat = lambda hb: None
conn.on_disconnect = self.stop
conn.connect(lambda: None)
self.wait()
class RabbitMQ_Queue(object):
def _start_new_connect(self):
self.conn=Connection(self.Queue_Server,username=self.Queue_User,password=self.Queue_PassWord
,vhost=self.Queue_Path,port=self.Queue_Port, io_loop=tornado.ioloop.IOLoop.instance())
self.conn.on_disconnect=self.on_queue_disconnect
self.conn.on_error=self.on_queue_error
self.conn.connect(self.on_connect)
def __init__(self,Queue_Server,Queue_User,Queue_PassWord,Queue_Path,BackQueueName,Queue_Port=None):
self.Queue_Server=Queue_Server
self.Queue_User=Queue_User
self.Queue_PassWord=Queue_PassWord
self.Queue_Path=Queue_Path
self.Queue_Port=Queue_Port
self.back_queue="WSBack-%s.resback"%BackQueueName
self._start_new_connect()
def on_connect(self):
if self.conn.status!=status.OPENED:
print 'connect rabbitmq fail'
self.conn.close(self.stop)
else:
print 'connect rabbitmq success'
self.channel = self.conn.channel()
self.channel.qos(prefetch_count=1)
self.channel.exchange_declare('front_end',type='topic',durable=True,callback=self.on_exchange_declare)
def on_exchange_declare(self):
self.channel.queue_declare(self.back_queue,auto_delete=True,callback=self.on_queue_back_created,durable=False)
print "exchange %s created"%'front_end'
#self.task_queue=qinfo.queue
global start_notified
if start_notified==False:
start_notified=True
msg=Message(body='{"func":"front_end_restart","parm":{}}',delivery_mode=2,reply_to=self.back_queue)
self.publish(msg)
def on_queue_back_created(self,qinfo):
print "back queue %s created"%qinfo.queue
self.back_queue=qinfo.queue
self.channel.queue_bind(self.back_queue,'front_end',self.back_queue,self.on_backqueue_bind)
consumer = Consumer(self.consume_callback)
self.channel.consume(qinfo.queue, consumer, no_ack=True)
def on_backqueue_bind(self):
print "back queue %s bind"%self.back_queue
def consume_callback(self,msg):
connid=msg.headers.get("connid",None)
if connid:
connids=connid.split("$")
for oneid in connids:
conn=connection_list.get(oneid,None)
if conn:
if int(msg.headers.get("close_connect",0)):
connection_list.pop(conn.connid,'')
conn.close()
conn.on_close()
continue
compressed=msg.headers.get('compression')=='application/x-gzip'
conn.SendData(msg.body,compressed)
def on_queue_disconnect(self):
time.sleep(5)
self._start_new_connect()
def on_queue_error(self,err):
time.sleep(5)
self._start_new_connect()
def publish(self,msg):
self.channel.publish(msg,'front_end','task.front')
