टॉरनाडो एप्लिकेशन में खरगोश एमक्यू (पिका लाइब्रेरी) को कैसे संवाद करें

Question

पिका लाइब्रेरी समर्थन टॉरनाडो एडाप्टर, here असीमित्रोन एडाप्टर का उपयोग करके संदेश प्रकाशित करने के बारे में एक उदाहरण है।

मैं टोरनाडो एप्लिकेशन में पिका का उपयोग करना चाहता हूं, बस एक उदाहरण, मैं खरगोश अनुरोध डेटा को RabbitMQ में रखना चाहता हूं, लेकिन यह नहीं पता कि इसे कैसे किया जाए।

दो प्रश्न यह नहीं जानते कि कैसे हल करें।

1 पिका उपयोग बवंडर एडाप्टर, अपने स्वयं के ioloop है

self._connection = pika.SelectConnection(pika.URLParameters(self._url), 
             self.on_connection_open) 
self._connection.ioloop.start() 

तूफान अनुप्रयोग की अपनी ioloop है,

tornado.ioloop.IOLoop.instance().start() 

कैसे उन दो ioloop गठबंधन करने के लिए?

2 पिका उदाहरण बार-बार एक ही संदेश प्रकाशित करता है, लेकिन मैं अनुरोध डेटा प्रकाशित करना चाहता हूं, विधि को प्रकाशित करने के लिए अनुरोध डेटा कैसे पास करना है?

Answer 1

बिल्कुल उसी चीज़ के लिए मेरी खोज पर मुझे यह blog post of Kevin Jing Qiu मिला।

मैं हर वेबसाकेट को अपने स्वयं के चैनल और कतारों के सेट देने के लिए खरगोश छेद चला गया।

मेरी परियोजना से निकास नीचे पाया जा सकता है। खरगोश एमक्यू से बंधे एक बवंडर आवेदन में इन भागों में शामिल हैं:

1. टोरनोडो एप्लिकेशन जो वेब अनुरोधों को संभालेगा। मैं यहां केवल लंबे समय तक रहते हुए वेबसाइकिल देखता हूं, लेकिन आप अल्पकालिक http अनुरोधों के साथ भी ऐसा कर सकते हैं।
2. ए (एक) PikaClient Instance
3. द्वारा एक वेब कनेक्शन जो उसके चैनल, कतार और एक्सचेंजों को परिभाषित करता है जब खुली विधि ट्रिगर होती है।

अब एक वेबस्केट कनेक्शन on_message के माध्यम से टर्ननाडो (ब्राउज़र से डेटा) से डेटा प्राप्त कर सकता है और इसे RabbitMQ पर भेज सकता है।

वेबस्केट कनेक्शन मूल_consume के माध्यम से RabbitMQ से डेटा प्राप्त करेगा।

यह पूरी तरह कार्यात्मक नहीं है, लेकिन आपको विचार प्राप्त करना चाहिए।

class PikaClient(object): 

    def __init__(self, io_loop): 
     logger.info('PikaClient: __init__') 
     self.io_loop = io_loop 

     self.connected = False 
     self.connecting = False 
     self.connection = None 
     self.channel = None 
     self.message_count = 0 
    """ 
    Pika-Tornado connection setup 
    The setup process is a series of callback methods. 
    connect:connect to rabbitmq and build connection to tornado io loop -> 
    on_connected: create a channel to rabbitmq -> 
    on_channel_open: declare queue tornado, bind that queue to exchange 
        chatserver_out and start consuming messages. 
    """ 

    def connect(self): 
     if self.connecting: 
      #logger.info('PikaClient: Already connecting to RabbitMQ') 
      return 

     #logger.info('PikaClient: Connecting to RabbitMQ') 
     self.connecting = True 

     cred = pika.PlainCredentials('guest', 'guest') 
     param = pika.ConnectionParameters(
      host='localhost', 
      port=5672, 
      virtual_host='/', 
      credentials=cred 
     ) 
     self.connection = TornadoConnection(param, 
      on_open_callback=self.on_connected,stop_ioloop_on_close=False) 
     self.connection.add_on_close_callback(self.on_closed) 

    def on_connected(self, connection): 
     logger.info('PikaClient: connected to RabbitMQ') 
     self.connected = True 
     self.connection = connection 
     # now you are able to call the pika api to do things 
     # this could be exchange setup for websocket connections to 
     # basic_publish to later. 
     self.connection.channel(self.on_channel_open) 

    def on_channel_open(self, channel): 
     logger.info('PikaClient: Channel %s open, Declaring exchange' % channel) 
     self.channel = channel 

    def on_closed(self, connection): 
     logger.info('PikaClient: rabbit connection closed') 
     self.io_loop.stop() 


class MyWebSocketHandler(websocket.WebSocketHandler): 
    def __init__(self): 
     self.status = 'not connected yet' 

    def open(self, *args, **kwargs): 
     self.status = "ws open" 
     self.rabbit_connect() # connect this websocket object to rabbitmq 

    def rabbit_connect(): 
     self.application.pc.connection.channel(self.rabbit_channel_in_ok) 

    def rabbit_channel_in_ok(self,channel): 
     self.channel_in = channel 
     self.channel_in.queue_declare(self.rabbit_declare_ok, 
             exclusive=True,auto_delete=True) 


# and so on... 


handlers = [ your_definitions_here_like_websockets_or_such ] 
settings = { your_settings_here } 
application = tornado.web.Application(handlers,**settings) 

def main(): 
    io_loop = tornado.ioloop.IOLoop.instance() 
    # PikaClient is our rabbitmq consumer 
    pc = PikaClient(io_loop) 
    application.pc = pc 
    application.pc.connect() 
    application.listen(config.tornadoport) 
    try: 
     io_loop.start() 
    except KeyboardInterrupt: 
     io_loop.stop() 

if __name__ == '__main__': 
    main()