टोर्नाडिओ 2 = बवंडर + सॉकेट.IO

सॉकेट क्या है?

यह एक पुस्तकालय है जो सर्वर और ब्राउज़र के बीच एक स्थायी संबंध स्थापित करने के लिए डिज़ाइन किया गया है।

पुस्तकालय का मुख्य लाभ: यह स्वचालित रूप से ब्राउज़र की क्षमताओं को समायोजित करता है और समर्थित सबसे कुशल परिवहन प्रोटोकॉल का उपयोग करता है।

क्या ब्राउज़र वेब सॉकेट में सक्षम है? महान, हम उनका उपयोग करेंगे। क्या ब्राउज़र को पता है कि AJAX का उपयोग कैसे किया जाता है? हम लंबे मतदान का उपयोग करेंगे। क्या यह एक प्राचीन इंटरनेट एक्सप्लोरर है? हम html फ़ाइल ऑब्जेक्ट का उपयोग करेंगे। अच्छी तरह से और इतने पर।

सॉकेट के बारे में।हियो पर पहले से ही लिखा है। "देशी" सॉकेट.IO सर्वर नोड में लिखा गया है। जेएसई

TornadIO2 क्या है?

यह टॉरनेडो के शीर्ष पर चलने वाली एक लाइब्रेरी है और सॉकेट.आईओ प्रोटोकॉल के वर्तमान संस्करण का समर्थन कर रही है।

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

इसे TornadIO2 क्यों कहा जाता है? क्योंकि टॉर्नेडियो है जो सॉकेट के पुराने संस्करणों का समर्थन करता है। और पुराने संस्करण (1.2 उदाहरण के लिए)। सॉकेट.आईओ 0.7 के साथ शुरू होने से, परिवहन प्रोटोकॉल बदल गया और नई कार्यक्षमता दिखाई दी जो पहले टोरनाडियो की वास्तुकला में अच्छी तरह से फिट नहीं हुई। इसके अलावा, TornadIO2 को Tornado 2.1 या उच्चतर की आवश्यकता होती है।

प्रोजेक्ट होम पेज यहां है: http://github.com/MrJoes/tornadio2
प्रलेखन (अंग्रेजी में) यहाँ है: http://tornadio2.readthedocs.org/

कोड के करीब

सबसे सरल सॉकेट.आईओ ग्राहक इस तरह दिखता है:

var conn = io.connect('http://myserver'); conn.on('connect', function() { alert('connected'); }); conn.on('message', function(msg) { alert('Got ' + msg); }); conn.on('disconnect', function() { alert('disconnected'); }); 

मोटे तौर पर, हम एक कनेक्शन ऑब्जेक्ट बनाते हैं, और फिर विभिन्न घटनाओं में प्रतिक्रियाएं जोड़ते हैं: कनेक्ट करना, एक संदेश प्राप्त करना, और सर्वर से डिस्कनेक्ट करना।

यदि हम सर्वर पर संदेश भेजना चाहते हैं, तो हम करते हैं:

 conn.send('Hello World!'); 

सॉकेट.आईओ जोसन वस्तुओं को भेजने का समर्थन करता है:

 conn.json.send({msg: 'Hello World', a: 10}); 

अब देखते हैं कि एक साधारण सर्वर कैसा दिखता है:

 from tornado import web from tornadio2 import SocketConnection, TornadioRouter, SocketServer # Declare connection class class MyConnection(SocketConnection): def on_open(self, info): print 'Client connected' def on_message(self, msg): print 'Got', msg self.send(msg) def on_close(self): print 'Client disconnected' # Create TornadIO2 router router = TornadioRouter(MyConnection) # Create Tornado application with urls from router app = web.Application(router.urls, socket_io_port=8001) # Start server if __name__ == '__main__': SocketServer(app) 

इस उदाहरण में, मुख्य हिस्सा MyConnection है । जब क्लाइंट सर्वर से जुड़ जाता है, तो TornadIO2 इस क्लास को तुरंत करेगा और on_open () कॉल करेगा । जब सर्वर क्लाइंट से एक संदेश प्राप्त करता है, तो यह भेजे गए संदेश के साथ on_message पर कॉल करेगा। और इसी तरह।

TornadioRouter एक कनेक्शन वर्ग के साथ काम करता है और सॉकेट के लिए आवश्यक सभी नेटवर्क लॉजिक को कार्यान्वित करता है। क्लाइंट ठीक से काम करने के लिए।

अगला, हम टोरनेडो एप्लिकेशन बनाते हैं, इसे राउटर से लिंक खिलाते हैं और सर्वर शुरू करते हैं। सॉकेटस्वर , टॉर्नेडो HTTP सर्वर और फ्लैश पॉलिसी सर्वर को शुरू करने के लिए बस एक सुविधाजनक आवरण है।

आप स्ट्रिंग्स और नियमित ऑब्जेक्ट दोनों को भेज सकते हैं, मुख्य बात यह है कि वे सामान्य रूप से json में क्रमबद्ध हैं।

घटनाओं

सॉकेट.आईओ के नवीनतम संस्करणों में, घटनाओं की अवधारणा दिखाई दी है - "सामान्य" संदेश भेजने के बजाय, एक फ़ंक्शन कॉल का अनुकरण किया जाता है और एक आरपीसी प्राप्त किया जाता है। स्वाभाविक रूप से, यदि आप मापदंडों (या उनके नामों) की संख्या के साथ गलती करते हैं, तो एक अपवाद होता है और कनेक्शन बस बंद हो जाता है।

घटना इस तरह से भेजी जाती है:

 var conn = io.connect('http://myserver:1234'); conn.on('connect', function() { conn.emit('hello', 'Joes'); }); 

और सर्वर पर वे इस तरह से संसाधित होते हैं:

 from tornadio2 import SocketConnection, event class MyConnection(SocketConnection): @event('hello') def hello(self, name): print 'Got hello from %s' % name 

सर्वर से घटनाओं को भेजना और उन्हें क्लाइंट पर संसाधित करना समान रूप से काम करता है:

 var conn = io.connect('http://myserver:1234'); conn.on('connect', function() { conn.emit('ping', 'Joes'); }); conn.on('pong', function(name) { alert(name); // Will show Joes }); 

और सर्वर:

 from tornadio2 import SocketConnection, event class MyConnection(SocketConnection): @event('ping') def ping(self, name): self.emit('pong', name) 

रसीद

एक संदेश या घटना भेजते समय, आप पुष्टि के लिए पूछ सकते हैं - जब संदेश प्राप्त होता है और संसाधित किया जाता है, तो एक एसीके पैकेट स्वचालित रूप से भेजा जाएगा और स्थानांतरित कॉलबैक कहा जाएगा।
घटनाओं के मामले में, आप हैंडलर से मूल्य वापस कर सकते हैं और यह स्वचालित रूप से क्लाइंट को भेजा जाएगा, इसलिए हमें REQUEST / RESPONSE पैटर्न के लिए एक सुविधाजनक कोड मिलता है।

एक एपीआई परिप्रेक्ष्य से, यह सब इस तरह दिखता है:

 var conn = io.connect('http://localhost'); conn.on('connect', function() { // Emit 'whoareyou' event and provide callback function that will be // called once event was handled by the server. conn.emit('whoareyou', function(name) { alert(name); // Will print 'Joes' }); }); 

और सर्वर:

 class MyConnection(SocketConnection): @event('whoareyou') def woohoo(self): return 'Joes' 

सर्वर भी पुष्टि की आवश्यकता के साथ संदेश भेज सकता है। ऐसा करने के लिए, या तो self.send () के लिए कॉलबैक पास करें या घटनाओं के लिए self.emit_ack () का उपयोग करें:

 class MyConnection(SocketConnection): @event('hello') def myhello(self): self.emit_ack('hello', self.on_ack) def on_ack(self, msg, data): print 'Woohoo, got ACK', msg, data 

Tornado.gen समर्थन करते हैं

टॉरनेडो संस्करण 2.1.0 के साथ शुरू, कॉलबैक के बिना अतुल्यकालिक कोड लिखने के लिए एक सुविधाजनक इंटरफ़ेस दिखाई दिया है।

Tornado.gen का उपयोग करते समय , कोड एसिंक्रोनस रूप से काम करेगा - यदि क्लाइंट से दो संदेश प्राप्त होते हैं और पहले एक को एसिंक्रोनस रूप से संसाधित किया जाता है, तो पहले वाले के खत्म होने से पहले दूसरे को संसाधित किया जाएगा। यह हमेशा सर्वर से अपेक्षित नहीं है।

इन उद्देश्यों के लिए tornadio2.gen.sync_engine डेकोरेटर विशेष रूप से बनाया गया था।

यदि आप डेकोरेटर में संदेश (या ईवेंट) हैंडलर को लपेटते हैं, तो संदेशों को उस क्रम में संसाधित किया जाएगा जो उन्हें प्राप्त हुआ था, लेकिन ioloop अवरुद्ध नहीं होगा।

एक उदाहरण को देखना सबसे अच्छा है जो दिखाता है कि यह सब कैसे काम करता है।

प्रदर्शन की निगरानी

TornadIO2 में एक साधारण मॉनिटर शामिल है जो विभिन्न घटनाओं को गिनता है: सक्रिय कनेक्शनों की संख्या, भेजे गए और प्राप्त संदेशों की संख्या प्रति सेकंड, और इसी तरह। काउंटरों की सूची अभी भी बहुत बड़ी नहीं है, इसलिए मुझे खुशी होगी।

एक सरल उदाहरण है जो दिखाता है कि आप डेटा के साथ कैसे काम कर सकते हैं - यह एक ग्राफ बनाता है और वास्तविक समय के आँकड़े दिखाता है जो कुछ इस तरह दिखता है:

उत्पादकता

दुर्भाग्य से, लाइब्रेरी का पूर्ण लोड परीक्षण अभी तक नहीं किया गया है, इसलिए मैं प्रदर्शन के बारे में कोई वास्तविक आंकड़े नहीं बना सकता हूं। अगर कोई भी परीक्षण करना चाहता है, तो मैं बहुत आभारी रहूंगा।

सर्वर कोड काफी हल्का है और ओवरहेड बहुत ध्यान देने योग्य नहीं होना चाहिए।

उदाहरण

TornadIO2 में कई उपयोग उदाहरण हैं: सरल चैट, सॉकेट के माध्यम से पिंग।
सभी उदाहरण यहाँ हैं ।

स्थिति और भविष्य

TornadIO2 अभी तक PyPI के साथ पंजीकृत नहीं है - जैसे ही यह है।

सर्वर उपयोग के लिए तैयार है (मुझे उम्मीद है) - यह आम तौर पर मेरी छोटी, बंद परियोजनाओं पर घूमता है। सभी प्रोटोकॉल काम करते हैं, इसलिए कोई विशेष आश्चर्य नहीं होना चाहिए।

मैं तनाव परीक्षण, त्रुटियों की पहचान करने में किसी भी मदद के लिए आभारी रहूंगा और मुझे उम्मीद है कि यह किसी और के काम आएगा।