अपने Django परियोजना के लिए बवंडर वेबस्केट चैट

मैंने हाल ही में वेबसाइट backgrounddating.com लॉन्च किया और इसके बारे में यहां हबराब्र पर लिखा । बेशक, मैंने पहले से ही इस परियोजना के कार्यान्वयन के कुछ तकनीकी विवरणों के बारे में बात की थी, लेकिन मैं साइट की विशेषताओं में से एक के बारे में अलग से लिखना चाहूंगा, खासकर क्योंकि इंटरनेट पर इस विषय पर अभी भी बहुत कम प्रलेखन (दोनों रूसी और अंग्रेजी में) हैं। । तो, हम दो उपयोगकर्ताओं के बीच वास्तविक समय चैट के बारे में बात करेंगे। कार्य यह है कि कोई भी उपयोगकर्ता अन्य उपयोगकर्ताओं को संदेश भेज सकता है, और यदि संदेश के प्राप्तकर्ता के पास इन उपयोगकर्ताओं के साथ चैट है, तो उसने तुरंत आने वाले संदेशों को देखा (अन्यथा, वह संदेशों को बाद में पढ़ सकता है: अर्थात, जब चैट खोला जाता है, तो यह लोड होता है हाल के पोस्ट का इतिहास)।

यदि आपको आवश्यकता है ताकि उपयोगकर्ता न केवल एक साथ, बल्कि किसी भी संख्या में लोगों के समूहों में संवाद कर सकें, तो यह लगभग तत्व रूप से किया जा सकता है: वर्णित कार्यान्वयन, वास्तव में, कार्यक्षमता के ऐसे विस्तार के लिए डिज़ाइन किया गया है।

मैं तुरंत स्पष्ट कर दूंगा कि इसे लागू करने का एकमात्र तरीका नहीं है। आप एक अन्य एसिंक्रोनस वेब सर्वर का उपयोग कर सकते हैं (उदाहरण के लिए, नोड.जेएस), आप एक अलग संदेश कतार का उपयोग कर सकते हैं (या इसका उपयोग बिल्कुल भी न करें यदि इस विकल्प की विशेषताएं आपको सूट करती हैं: वेब सर्वर का एक ही कार्यकर्ता हमेशा एक ही चैनल के उपयोगकर्ताओं के साथ संचार करता है)। मैं यह भी दावा नहीं करता कि यह विकल्प सबसे अच्छा है (लेकिन इस मामले में इसने सबसे अच्छा काम किया है)। अंत में, हम पुराने ब्राउज़रों के लिए बैसाखी (लंबे समय तक मतदान, फ्लैश) पर विचार नहीं करेंगे (और ये IE के लगभग सभी संस्करण हैं, उदाहरण के लिए) जो वेब सॉकेट का समर्थन नहीं करते हैं, और हम पहले से ही ब्राउज़रों से कनेक्ट होने पर भी विचार नहीं करते हैं। WebSocket प्रोटोकॉल का समर्थन करें, लेकिन एक मानकीकृत संस्करण ( RFC 6455 ) नहीं, बल्कि अप्रचलित में से एक। ड्राफ्ट 76 (उर्फ हिक्सी -76) के पुराने संस्करण के लिए समर्थन को सक्षम करने के तरीके के बारे में जानकारी के लिए, बवंडर प्रलेखन देखें ।

फिर भी, कोई निश्चित रूप से कह सकता है - यह विधि अच्छी तरह से काम करती है, और एक परियोजना में नहीं, लेकिन कई में (वर्णित कार्यान्वयन विधि लंबे समय तक उपयोग की गई है, हालांकि इसके बारे में बहुत अधिक जानकारी नहीं है)। उदाहरण के लिए, बैकग्राउंड डेटिंग चलाने वाला सर्वर वर्तमान में लिनोड (512 MiB मेमोरी) से सबसे कम उम्र का VPS है, लेकिन प्रोसेसर लोड 20-40 प्रतिशत से अधिक नहीं बढ़ा है, और रैम का उपयोग लगभग 30% था। इसके अलावा, संसाधन मुख्य रूप से gunicorn (Django पर चलने वाले वेब सर्वर) और PostgreSQL द्वारा उपयोग किए जाते हैं। लेकिन इसमें कुछ भी आश्चर्य की बात नहीं है, क्योंकि यह कोई रहस्य नहीं है कि टॉर्नेडो न केवल जल्दी से काम करने के लिए पर्याप्त प्रकाश है, बल्कि सी 10k (जो पहले से ही हब्राहब्र पर था) के साथ सामना करने के लिए।

तो, हम Django 1.4.2, Tornado 2.4, Redis 2.6.5 और PostgreSQL 9.2.1 का उपयोग करेंगे (वास्तव में, आप एक और रिलेशनल DBMS का उपयोग कर सकते हैं - Django के कई अलग-अलग बैकेंड हैं)। रेडिस से जुड़ने के लिए पायथन और ब्रिंडसवा के लिए रेडिस-पी क्लाइंट मानक (टॉर्नेडो के साथ अतुल्यकालिक रेडिस क्लाइंट) का उपयोग किया जाएगा। सर्वर पर यह सब तैनात करने के लिए, हम हाइपोक्सी और नेग्नेक्स का उपयोग करेंगे, हम उत्पादन में Django परियोजना को लॉन्च करने के लिए gunicorn वेब सर्वर का उपयोग करेंगे, और पर्यवेक्षक Django और Tadoado के लिए वेब सर्वर के लॉन्च को नियंत्रित करेगा।

यदि आपको लगता है कि आपके पास सैद्धांतिक ज्ञान की कमी है (उदाहरण के लिए, आप काफी समझ में नहीं आते हैं कि एक अतुल्यकालिक गैर-अवरुद्ध वेब सर्वर, संदेश कतार और इतने पर क्या है), तो मेरा सुझाव है कि आप पहले संबंधित दस्तावेज पढ़ें, और यदि आपके पास प्रश्न हैं, तो लिखें टिप्पणियाँ (या मुझे मेल करें)। मैं गुरु इवान सगलाएव द्वारा उत्कृष्ट पायथन फोरम पर ( 1 , 2 , 3 , 4 , 5 , 6 , 7 ) विषय पर कई चर्चाओं पर ध्यान देने की सलाह देता हूं, साथ ही रिपोर्ट की स्लाइड्स पर "एक अतुल्यकालिक एक के साथ एक तुल्यकालिक रूपरेखा को जोड़ना (उदाहरण के रूप में django का उपयोग करके)" एक और पायथन गुरु, मिखाइल कोरोबोव , देवकोनफ 2011 में पढ़ा गया।

विचाराधीन समाधान के स्रोत इस लेख में और गिटहब दोनों पर मौजूद हैं।

Django सेटअप

एक Django परियोजना बनाएं और दिखाई देने वाली निर्देशिका पर जाएं:

 django-admin.py startproject myproject
 सीडी myproject /

अब myproject / settings.py फ़ाइल को एडिट करें।

सबसे पहले, उपयोगकर्ता सत्रों के बारे में जानकारी संग्रहीत करने के लिए रेडिस बैकएंड का उपयोग करने के लिए तुरंत स्विच करना बहुत अच्छा विचार है। यह सभी परियोजनाओं में करने के लायक है (उन लोगों को छोड़कर, जहां किसी कारण से आप रेडिस का उपयोग नहीं कर सकते हैं, साथ ही साथ जहां उन लोगों की योजना नहीं है)। ऐसा करने के लिए, django-redis-session (pip install django-redis-session) स्थापित करें और सेटिंग्स में जोड़ें:

SESSION_ENGINE = 'redis_sessions.session' 

बधाई, आपने केवल 1 से कम की गई साइट पर प्रश्न भेजते समय डेटाबेस में प्रश्नों की संख्या बना दी (Redis तुरंत प्रश्नों का जवाब देते हैं)। :)

वैसे, ऐसी सेटिंग्स एक अलग फ़ाइल में सबसे अच्छी तरह से सहेजी जाती हैं जिसे आप gitignore में जोड़ते हैं - आमतौर पर local_settings.py

वहां आप परियोजना की गुप्त कुंजी को स्थानांतरित कर सकते हैं, उदाहरण के लिए (SECRET_KEY), साथ ही डेटाबेस सेटिंग्स। यहाँ मुद्दा यह है कि, सबसे पहले, आप एक विशिष्ट सर्वर (स्थानीय डेटाबेस, कैशिंग बैकएंड, सत्र बैकएंड, डिबग मोड सेटिंग्स) में local_settings.py, और दूसरी तरह Git (या किसी अन्य संस्करण नियंत्रण प्रणाली) के लिए विशिष्ट सेटिंग्स को सहेज सकते हैं। कुंजी और पासवर्ड के बारे में जानकारी संग्रहीत नहीं करेगा।

तदनुसार, ऐसी सेटिंग को local_settings.py में जोड़ने के लिए, आपको सेटिंग के अंत में निम्नलिखित जोड़ने की आवश्यकता है:

 try: from local_settings import * except ImportError: pass 

इसके बाद, डेटाबेस (DATABASES) को कॉन्फ़िगर करना न भूलें, टेम्प्लेट डायरेक्टरी निर्दिष्ट करें, स्टेटिक फाइल्स की डायरेक्टरी और एपीआई की (Tornado, एसिंक्रोनस रूप से Django को रिक्वेस्ट भेजेगा और Django डेटाबेस में इस मैसेज को एक नया मैसेज प्राप्त करने से बचाएगा), साथ ही URL भी। जिस पर आपको अनुरोध भेजने की आवश्यकता है।

ताकि जब आप साइट को किसी अन्य सर्वर पर तैनात करें (या एफएस में प्रोजेक्ट को किसी अन्य स्थान पर रखते समय) तो आपको टेम्पलेट और स्थिर फ़ाइलों की निर्देशिका में पथ बदलने की आवश्यकता नहीं है, ऊपर दिए गए सेटिंग्स में निम्नलिखित जोड़कर स्टार्टअप पर परियोजना का स्थान निर्धारित करना सबसे अच्छा है:

 import os PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__)) 

और फिर, तदनुसार, PROJECT_ROOT पर आधारित अन्य पथ प्राप्त करें।

स्थैतिक फ़ाइलें:

 STATICFILES_DIRS = ( os.path.join(PROJECT_ROOT, "static"), ) 

टेम्पलेट्स:

 TEMPLATE_DIRS = ( os.path.join(PROJECT_ROOT, "templates"), ) 

एपीआई कुंजी और पता:

 API_KEY = '$0m3-U/\/1qu3-K3Y' SEND_MESSAGE_API_URL = 'http://127.0.0.1:8000/messages/send_message_api' 

एक कुंजी उत्पन्न करने के लिए, आप कंसोल में इस सरल रेखा का उपयोग कर सकते हैं (वैसे, इमोटिकॉन आपको वहां से दिखता है):

 </ dev / urandom trdc _A-Zaz-0-9 |  सिर -c $ {1: -32}; गूंज;

अब यह मायप्रोजेक्ट डायरेक्टरी (जहां सेटिंग्स ओरोमो और लोकल_सेटसेट्सहोम स्थित हैं) में डायरेक्टरी को स्टैटिक और टेम्प्लेट बनाने के लिए बना हुआ है और चैट एप्लिकेशन लिखना शुरू करें।

चैट (Django)

एक नया एप्लिकेशन जोड़ें:

 python निजीकृत स्टार्टअप को प्रबंधित करता है

और मॉडल लिखें (Privatemessages / model.py):

 from django.db import models from django.db.models.signals import post_save from django.contrib.auth.models import User # Create your models here. class Thread(models.Model): participants = models.ManyToManyField(User) last_message = models.DateTimeField(null=True, blank=True, db_index=True) class Message(models.Model): text = models.TextField() sender = models.ForeignKey(User) thread = models.ForeignKey(Thread) datetime = models.DateTimeField(auto_now_add=True, db_index=True) def update_last_message_datetime(sender, instance, created, **kwargs): """ Update Thread's last_message field when a new message is sent. """ if not created: return Thread.objects.filter(id=instance.thread.id).update( last_message=instance.datetime ) post_save.connect(update_last_message_datetime, sender=Message) 

कुछ भी जटिल नहीं है - संदेश और धागे (थ्रेड) हैं। प्रत्येक दो उपयोगकर्ताओं के लिए एक थ्रेड बनाया जाएगा, और उनके सभी संदेश इस थ्रेड से संबंधित होंगे। जब एक नया संदेश बनाया जाता है, तो संबंधित थ्रेड के लिए अंतिम संदेश की तारीख और समय अपडेट किया जाता है।

अब सेटिंग में INSTALLED_APPS में एप्लिकेशन जोड़ने और डेटाबेस के साथ मॉडल को सिंक्रनाइज़ करने का समय है:

 python manage.py syncdb

आइए, Privatemessages / views.py खोलें और 4 विचार लिखें:

• send_message_view - Django के माध्यम से एक संदेश भेजने के लिए (उदाहरण के लिए, यदि यह दो लोगों के बीच पहला संदेश है)
• send_message_api_view - बवंडर के माध्यम से संदेश भेजने के लिए
• messages_view - वार्ताकारों की सूची देखने के लिए (अंतिम संदेश के दिनांक और समय के अवरोही क्रम में क्रमबद्ध)
• chat_view - चैट के लिए (Django केवल उन संदेशों के साथ एक पृष्ठ लौटाएगा जो पहले से ही डेटाबेस में हैं, और फिर ब्राउज़र WS के माध्यम से टोरनेडो सर्वर से कनेक्ट होगा और वास्तविक समय में नए संदेश प्राप्त / भेज देगा, बिना पृष्ठ को फिर से लोड किए बिना और अतिरिक्त HTTP के बिना। क्वेरी)

 # Create your views here. import json import redis from django.shortcuts import render_to_response, get_object_or_404 from django.http import HttpResponse, HttpResponseRedirect from django.template import RequestContext from django.core.urlresolvers import reverse from django.utils import timezone from django.views.decorators.csrf import csrf_exempt from django.conf import settings from django.contrib.auth.models import User from privatemessages.models import Thread, Message from privatemessages.utils import json_response, send_message def send_message_view(request): if not request.method == "POST": return HttpResponse("Please use POST.") if not request.user.is_authenticated(): return HttpResponse("Please sign in.") message_text = request.POST.get("message") if not message_text: return HttpResponse("No message found.") if len(message_text) > 10000: return HttpResponse("The message is too long.") recipient_name = request.POST.get("recipient_name") try: recipient = User.objects.get(username=recipient_name) except User.DoesNotExist: return HttpResponse("No such user.") if recipient == request.user: return HttpResponse("You cannot send messages to yourself.") thread_queryset = Thread.objects.filter( participants=recipient ).filter( participants=request.user ) if thread_queryset.exists(): thread = thread_queryset[0] else: thread = Thread.objects.create() thread.participants.add(request.user, recipient) send_message( thread.id, request.user.id, message_text, request.user.username ) return HttpResponseRedirect( reverse('privatemessages.views.messages_view') ) @csrf_exempt def send_message_api_view(request, thread_id): if not request.method == "POST": return json_response({"error": "Please use POST."}) api_key = request.POST.get("api_key") if api_key != settings.API_KEY: return json_response({"error": "Please pass a correct API key."}) try: thread = Thread.objects.get(id=thread_id) except Thread.DoesNotExist: return json_response({"error": "No such thread."}) try: sender = User.objects.get(id=request.POST.get("sender_id")) except User.DoesNotExist: return json_response({"error": "No such user."}) message_text = request.POST.get("message") if not message_text: return json_response({"error": "No message found."}) if len(message_text) > 10000: return json_response({"error": "The message is too long."}) send_message( thread.id, sender.id, message_text ) return json_response({"status": "ok"}) def messages_view(request): if not request.user.is_authenticated(): return HttpResponse("Please sign in.") threads = Thread.objects.filter( participants=request.user ).order_by("-last_message") if not threads: return render_to_response('private_messages.html', {}, context_instance=RequestContext(request)) r = redis.StrictRedis() user_id = str(request.user.id) for thread in threads: thread.partner = thread.participants.exclude(id=request.user.id)[0] thread.total_messages = r.hget( "".join(["thread_", str(thread.id), "_messages"]), "total_messages" ) return render_to_response('private_messages.html', { "threads": threads, }, context_instance=RequestContext(request)) def chat_view(request, thread_id): if not request.user.is_authenticated(): return HttpResponse("Please sign in.") thread = get_object_or_404( Thread, id=thread_id, participants__id=request.user.id ) messages = thread.message_set.order_by("-datetime")[:100] user_id = str(request.user.id) r = redis.StrictRedis() messages_total = r.hget( "".join(["thread_", thread_id, "_messages"]), "total_messages" ) messages_sent = r.hget( "".join(["thread_", thread_id, "_messages"]), "".join(["from_", user_id]) ) if messages_total: messages_total = int(messages_total) else: messages_total = 0 if messages_sent: messages_sent = int(messages_sent) else: messages_sent = 0 messages_received = messages_total-messages_sent partner = thread.participants.exclude(id=request.user.id)[0] tz = request.COOKIES.get("timezone") if tz: timezone.activate(tz) return render_to_response('chat.html', { "thread_id": thread_id, "thread_messages": messages, "messages_total": messages_total, "messages_sent": messages_sent, "messages_received": messages_received, "partner": partner, }, context_instance=RequestContext(request)) 

और यहाँ प्राइवेटमैसेज / utils.py है:

 import json import redis from django.utils import dateformat from privatemessages.models import Message def json_response(obj): """ This function takes a Python object (a dictionary or a list) as an argument and returns an HttpResponse object containing the data from the object exported into the JSON format. """ return HttpResponse(json.dumps(obj), content_type="application/json") def send_message(thread_id, sender_id, message_text, sender_name=None): """ This function takes Thread object id (first argument), sender id (second argument), message text (third argument) and can also take sender's name. It creates a new Message object and increases the values stored in Redis that represent the total number of messages for the thread and the number of this thread's messages sent from this specific user. If a sender's name is passed, it also publishes the message in the thread's channel in Redis (otherwise it is assumed that the message was already published in the channel). """ message = Message() message.text = message_text message.thread_id = thread_id message.sender_id = sender_id message.save() thread_id = str(thread_id) sender_id = str(sender_id) r = redis.StrictRedis() if sender_name: r.publish("".join(["thread_", thread_id, "_messages"]), json.dumps({ "timestamp": dateformat.format(message.datetime, 'U'), "sender": sender_name, "text": message_text, })) for key in ("total_messages", "".join(["from_", sender_id])): r.hincrby( "".join(["thread_", thread_id, "_messages"]), key, 1 ) 

आप समय क्षेत्र के साथ काम करने पर Django प्रलेखन में tz.activate () के बारे में पढ़ सकते हैं। चूंकि ब्राउज़र समय क्षेत्र के बारे में जानकारी प्रदान नहीं करते हैं (उदाहरण के लिए, भाषा के बारे में जानकारी के विपरीत), हमें टाइमज़ोन नामक ग्राहक पक्ष पर एक कुकी बनाने की आवश्यकता है - इस तरह से Django समय क्षेत्र में प्रत्येक संदेश की तारीख और समय प्रदर्शित करने में सक्षम होगा जिसमें पल उपयोगकर्ता है।

क्लाइंट पक्ष पर समय क्षेत्र की गणना करने के लिए, हम jstz लाइब्रेरी का उपयोग करेंगे (myproject / static directory में jstz.min.js रखना न भूलें)। ऐसे अन्य समाधान हैं जो आपको उपयोगकर्ता के समय क्षेत्र को निर्धारित करने की अनुमति देते हैं: उदाहरण के लिए, आप जियोआईपी डेटाबेस के आधार पर सबसे अधिक संभावना समय क्षेत्र ले सकते हैं या यहां तक ​​कि सर्वर पर स्थानीय समय के साथ उपयोगकर्ता के कंप्यूटर पर स्थानीय समय की तुलना कर सकते हैं (क्योंकि हम जानते हैं कि समय सर्वर पर सही ढंग से सेट है) - ऐसा समाधान आपको इस घटना में उपयोगकर्ता के वास्तविक समय क्षेत्र का पता लगाने की अनुमति देता है कि कुछ पूरी तरह से अलग समय क्षेत्र उसके सिस्टम में चुना गया है, लेकिन समय मैन्युअल रूप से समय क्षेत्र के अनुरूप करने के लिए स्थानांतरित किया गया था।

लेकिन इस मामले में, मान लें कि यदि उपयोगकर्ता के पास गलत समय क्षेत्र निर्धारित है, तो समय की अशुद्धि की सबसे अधिक संभावना उसे सूट करती है (अन्यथा यह सेटिंग्स बदलने के लिए एक अतिरिक्त अनुस्मारक होगा)।

यह भी ध्यान दें कि आपको pytz (pip install pytz) इंस्टॉल करने की आवश्यकता होगी - ऑलसन डेटाबेस ( IANA टाइम ज़ोन डेटाबेस ) के प्रारूप में एक स्ट्रिंग से टाइम ज़ोन प्राप्त करने के लिए यह आवश्यक है।

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

जब कोई उपयोगकर्ता एक चैट खोलता है और उसका ब्राउज़र एक Tornado सर्वर के साथ एक WS-कनेक्शन खोलता है, तो Tornado सर्वर Redis में थ्रेड चैनल की सदस्यता लेता है, और जब नए संदेश दिखाई देते हैं, तो यह तुरंत उन्हें उपयोगकर्ता को भेजता है।

यदि आप Redis (SUBSCRIBE, UNSUBSCRIBE, और PUBLISH कमांड्स) में Pub / Sub कार्यान्वयन से परिचित नहीं हैं, तो आप इसके बारे में Redis प्रलेखन में पढ़ सकते हैं।

जब send_messages फ़ंक्शन कॉल send_message_view और गुजरता है, विशेष रूप से, प्रेषक का नाम, फ़ंक्शन Redis में इस थ्रेड के चैनल पर एक संदेश प्रकाशित करता है। Send_message_api_view के मामले में, प्रेषक का नाम प्रेषित नहीं होता है, और यह माना जाता है कि संदेश इस धागे के चैनल को पहले ही भेजा जा चुका है, send_message_api_view (यह करने से पहले ही संदेश प्रेषित हो जाता है ताकि उपयोगकर्ताओं से चैटिंग के बीच जितनी जल्दी हो सके संचार हो जाए - डेटाबेस में सहेजना असंगत रूप से होता है। , चैनल पर प्रकाशन के बाद)।

अब Privatemessages / urls.py फ़ाइल बनाएं और Django विधियों के लिए urlpatterns सेट करें:

 from django.conf.urls import patterns, url urlpatterns = patterns('privatemessages.views', url(r'^send_message/$', 'send_message_view'), url(r'^send_message_api/(?P<thread_id>\d+)/$', 'send_message_api_view'), url(r'^chat/(?P<thread_id>\d+)/$', 'chat_view'), url(r'^$', 'messages_view'), ) 

और हां, उन्हें रूट URLconf (myproject / urls.py) में शामिल करें:

 from django.conf.urls import patterns, include, url # something else urlpatterns = patterns('', # something else url(r'^messages/', include('privatemessages.urls')), # something else ) 

टेम्पलेट निर्देशिका में आपको chat.html और priv_messages.html रखने की आवश्यकता है। आधार टेम्पलेट base.html भी जोड़ें।

base.html

 <!DOCTYPE html> <html> <head> <link rel="stylesheet" type="text/css" href="/static/privatemessages.css"> <script type="text/javascript" src="http://yandex.st/jquery/1.8.3/jquery.min.js"></script> <script type="text/javascript" src="/static/jstz.min.js"></script> <script type="text/javascript" src="/static/privatemessages.js"></script> {% block head %}{% endblock %} <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> <title>{% block title %} {% endblock title %}</title> </head> <body> {% block content %}{% endblock content %} </body> </html> 

chat.html

 {% extends "base.html" %} {% block title %}{{ partner.username }}{% endblock %} {% block head %} <script type="text/javascript"> $(document).ready(function() { activate_chat({{ thread_id }}, "{{ user.username }}", { "total": {{ messages_total }}, "sent": {{ messages_sent }}, "received": {{ messages_received }} }); }); </script> {% endblock %} {% block content %} {% load pluralize %} <div class="chat"> <div class="partner"> <p class="name">{{ partner.username }}</p> <p class="messages"><span class="total">{{ messages_total }}</span> {{ messages_total|rupluralize:",," }} (<span class="received">{{ messages_received }}</span> , <span class="sent">{{ messages_sent }}</span> )</p> </div> <div class="conversation"> {% for message in thread_messages reversed %} <div class="message"> {% if message.sender == user %}<p class="author we"><span class="datetime">{{ message.datetime|date:"dmY H:i:s" }}</span> {{ user.username }}:</p>{% else %}<p class="author partner"><span class="datetime">{{ message.datetime|date:"dmY H:i:s" }}</span> {{ partner.username }}:</p>{% endif %} <p class="message">{{ message.text|linebreaksbr }}</p> </div> {% endfor %} </div> <form class="message_form"> <div class="compose"> <textarea rows="1" cols="30" id="message_textarea"></textarea> </div> <div class="send"> <button class="btn" type="button"></button> <p>        Ctrl + Enter.</p> </div> </form> </div> {% endblock content %} 

private_messages.html

 {% extends "base.html" %} {% block content %} {% load pluralize %} <div class="private_messages"> <h1></h1> <div class="partners"> {% for thread in threads %} <p><a href="{% url privatemessages.views.chat_view thread.id %}">{{ thread.partner.username }} ({{ thread.total_messages|default_if_none:"0" }} {{ thread.total_messages|rupluralize:",," }})</a></p> {% empty %} <p>   .</p> {% endfor %} </div> <h1> </h1> <form action="{% url privatemessages.views.send_message_view %}" method="post" class="new_message"> {% csrf_token %} <p class="name"><input name="recipient_name" placeholder=" "></p> <p><textarea name="message" placeholder=""></textarea></p> <p><input type="submit" value=""></p> </form> </div> {% endblock content %} 

और __init__.py और pluralize.py फाइलों के साथ प्राइवेटमैसेज / टेम्प्लेटैट्स डायरेक्टरी बनाएं।

Privatemessages / templatetags / pluralize.py ( फ़िल्टर लेखक - V @ s3K):

 from django import template register = template.Library() @register.filter def rupluralize(value, arg): args = arg.split(",") try: number = abs(int(value)) except TypeError: number = 0 a = number % 10 b = number % 100 if (a == 1) and (b != 11): return args[0] elif (a >= 2) and (a <= 4) and ((b < 10) or (b >= 20)): return args[1] else: return args[2] 

शैलियाँ जोड़ें (myproject / static / privmessages.css):

 html, body { height: 100%; margin: 0; } body { font-family: Geneva, Arial, Helvetica, sans-serif; font-size: 14px; color: #000; background: #fff; } textarea, form p.name input { border: 1px #d4d4d4 solid; } form.new_message p { margin: 4px 0; } form.new_message p.name input, form.new_message textarea { width: 300px; } form.new_message textarea { height: 100px; } textarea:focus, input.name:focus { border-color: #cacaca; -webkit-box-shadow: 0 1px 1px rgba(0, 0, 0, 0.075) inset, 0 0 3px rgba(150, 150, 150, 0.5); -moz-box-shadow: 0 1px 1px rgba(0, 0, 0, 0.075) inset, 0 0 3px rgba(150, 150, 150, 0.5); box-shadow: 0 1px 1px rgba(0, 0, 0, 0.075) inset, 0 0 3px rgba(150, 150, 150, 0.5); } div.private_messages { padding: 10px; } div.private_messages h1 { margin-top: 0; } div.private_messages div.partners { margin-bottom: 30px; } div.chat { height: 100%; min-height: 400px; min-width: 600px; position: relative; background-color: #e0e0e0; } div.chat div.partner { height: 50px; padding: 5px; } div.chat div.partner p { margin: 0; } div.chat div.partner p.name { font-weight: bold; margin-bottom: 3px; } div.chat div.conversation { position: absolute; top: 50px; left: 5px; right: 5px; bottom: 140px; overflow: auto; padding: 0 5px; border-style: solid; border-color: #eee; border-width: 10px 0; background-color: #fff; -webkit-border-radius: 7px; -moz-border-radius: 7px; border-radius: 7px; } div.chat div.conversation div.message { padding: 5px 0; } div.chat div.conversation div.message p { margin: 0; } div.chat div.conversation div.message p.author.partner { color: #002c64; } div.chat div.conversation div.message p.author.we { color: #216300; } div.chat div.conversation div.message p.author span.datetime { font-size: 12px; } div.chat form.message_form { position: absolute; margin: 0; left: 0; right: 0; bottom: 5px; height: 130px; } div.chat form.message_form div.outdated_browser_message { margin: 10px 5px; } div.chat form.message_form div.compose { float: left; height: 100%; width: 80%; padding: 0 5px; -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; } div.chat form.message_form div.compose textarea { width: 100%; height: 100%; margin: 0; -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; resize: none; } div.chat form.message_form div.send { float: left; height: 100%; width: 20%; min-width: 100px; padding-right: 5px; -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; } div.chat form.message_form div.send p { margin-top: 5px; color: #333; } div.chat form.message_form div.send button { width: 100%; -webkit-box-sizing: border-box; -moz-box-sizing: border-box; box-sizing: border-box; } 

और जावास्क्रिप्ट (myproject / static / privatemessages.js):

 function getCookie(name) { var cookieValue = null; if (document.cookie && document.cookie != '') { var cookies = document.cookie.split(';'); for (var i = 0; i < cookies.length; i++) { var cookie = jQuery.trim(cookies[i]); // Does this cookie string begin with the name we want? if (cookie.substring(0, name.length + 1) == (name + '=')) { cookieValue = decodeURIComponent(cookie.substring(name.length + 1)); break; } } } return cookieValue; } function setCookie(key, value) { document.cookie = escape(key) + '=' + escape(value); } function getNumEnding(iNumber, aEndings) { var sEnding, i; iNumber = iNumber % 100; if (iNumber>=11 && iNumber<=19) { sEnding=aEndings[2]; } else { i = iNumber % 10; switch (i) { case (1): sEnding = aEndings[0]; break; case (2): case (3): case (4): sEnding = aEndings[1]; break; default: sEnding = aEndings[2]; } } return sEnding; } var timezone = getCookie('timezone'); if (timezone == null) { setCookie("timezone", jstz.determine().name()); } function activate_chat(thread_id, user_name, number_of_messages) { $("div.chat form.message_form div.compose textarea").focus(); function scroll_chat_window() { $("div.chat div.conversation").scrollTop($("div.chat div.conversation")[0].scrollHeight); } scroll_chat_window(); var ws; function start_chat_ws() { ws = new WebSocket("ws://127.0.0.1:8888/" + thread_id + "/"); ws.onmessage = function(event) { var message_data = JSON.parse(event.data); var date = new Date(message_data.timestamp*1000); var time = $.map([date.getHours(), date.getMinutes(), date.getSeconds()], function(val, i) { return (val < 10) ? '0' + val : val; }); $("div.chat div.conversation").append('<div class="message"><p class="author ' + ((message_data.sender == user_name) ? 'we' : 'partner') + '"><span class="datetime">' + time[0] + ':' + time[1] + ':' + time[2] + '</span> ' + message_data.sender + ':</p><p class="message">' + message_data.text.replace(/&/g,'&amp;').replace(/</g,'&lt;').replace(/>/g,'&gt;').replace(/\n/g, '<br />') + '</p></div>'); scroll_chat_window(); number_of_messages["total"]++; if (message_data.sender == user_name) { number_of_messages["sent"]++; } else { number_of_messages["received"]++; } $("div.chat p.messages").html('<span class="total">' + number_of_messages["total"] + '</span> ' + getNumEnding(number_of_messages["total"], ["", "", ""]) + ' (<span class="received">' + number_of_messages["received"] + '</span> , <span class="sent">' + number_of_messages["sent"] + '</span> )'); } ws.onclose = function(){ // Try to reconnect in 5 seconds setTimeout(function() {start_chat_ws()}, 5000); }; } if ("WebSocket" in window) { start_chat_ws(); } else { $("form.message_form").html('<div class="outdated_browser_message"><p><em>!</em>    . ,    :</p><ul><li> <em>Android</em>: <a href="http://www.mozilla.org/ru/mobile/">Firefox</a>, <a href="http://www.google.com/intl/en/chrome/browser/mobile/android.html">Google Chrome</a>, <a href="https://play.google.com/store/apps/details?id=com.opera.browser">Opera Mobile</a></li><li> <em>Linux</em>, <em>Mac OS X</em>  <em>Windows</em>: <a href="http://www.mozilla.org/ru/firefox/fx/">Firefox</a>, <a href="https://www.google.com/intl/ru/chrome/browser/">Google Chrome</a>, <a href="http://ru.opera.com/browser/download/">Opera</a></li></ul></div>'); return false; } function send_message() { var textarea = $("textarea#message_textarea"); if (textarea.val() == "") { return false; } if (ws.readyState != WebSocket.OPEN) { return false; } ws.send(textarea.val()); textarea.val(""); } $("form.message_form div.send button").click(send_message); $("textarea#message_textarea").keydown(function (e) { // Ctrl + Enter if (e.ctrlKey && e.keyCode == 13) { send_message(); } }); } 

एक सर्वर पर तैनाती करते समय, उस पते को निर्दिष्ट करना न भूलें जहां टॉरनेडो सर्वर उपलब्ध होगा (या इसे एक अलग चर में भी डाल दिया जाए)।

चैट (बवंडर)

हम एक नया बवंडर आवेदन लिखेंगे और इसे निजीकृत / बवंडरएपीडीओ में सहेजेंगे:

 import datetime import json import time import urllib import brukva import tornado.web import tornado.websocket import tornado.ioloop import tornado.httpclient from django.conf import settings from django.utils.importlib import import_module session_engine = import_module(settings.SESSION_ENGINE) from django.contrib.auth.models import User from privatemessages.models import Thread c = brukva.Client() c.connect() class MainHandler(tornado.web.RequestHandler): def get(self): self.set_header('Content-Type', 'text/plain') self.write('Hello. :)') class MessagesHandler(tornado.websocket.WebSocketHandler): def __init__(self, *args, **kwargs): super(MessagesHandler, self).__init__(*args, **kwargs) self.client = brukva.Client() self.client.connect() def open(self, thread_id): session_key = self.get_cookie(settings.SESSION_COOKIE_NAME) session = session_engine.SessionStore(session_key) try: self.user_id = session["_auth_user_id"] self.sender_name = User.objects.get(id=self.user_id).username except (KeyError, User.DoesNotExist): self.close() return if not Thread.objects.filter( id=thread_id, participants__id=self.user_id ).exists(): self.close() return self.channel = "".join(['thread_', thread_id,'_messages']) self.client.subscribe(self.channel) self.thread_id = thread_id self.client.listen(self.show_new_message) def handle_request(self, response): pass def on_message(self, message): if not message: return if len(message) > 10000: return c.publish(self.channel, json.dumps({ "timestamp": int(time.time()), "sender": self.sender_name, "text": message, })) http_client = tornado.httpclient.AsyncHTTPClient() request = tornado.httpclient.HTTPRequest( "".join([ settings.SEND_MESSAGE_API_URL, "/", self.thread_id, "/" ]), method="POST", body=urllib.urlencode({ "message": message.encode("utf-8"), "api_key": settings.API_KEY, "sender_id": self.user_id, }) ) http_client.fetch(request, self.handle_request) def show_new_message(self, result): self.write_message(str(result.body)) def on_close(self): try: self.client.unsubscribe(self.channel) except AttributeError: pass def check(): if self.client.connection.in_progress: tornado.ioloop.IOLoop.instance().add_timeout( datetime.timedelta(0.00001), check ) else: self.client.disconnect() tornado.ioloop.IOLoop.instance().add_timeout( datetime.timedelta(0.00001), check ) application = tornado.web.Application([ (r"/", MainHandler), (r'/(?P<thread_id>\d+)/', MessagesHandler), ]) 

इस आवेदन में लगभग सब कुछ tornado.ioloop का उपयोग करते हुए अतुल्यकालिक रूप से चलता है। एक अपवाद सत्र पहचानकर्ता द्वारा उपयोगकर्ता का प्राधिकरण है (और डेटाबेस से उसका नाम प्राप्त करना)। यह एक ब्लॉकिंग ऑपरेशन है, अर्थात, इस समय, इस टोरनेडो सर्वर से जुड़े अन्य उपयोगकर्ता प्रतीक्षा करेंगे। यदि आपको इसकी आवश्यकता है, तो इसे बदलना आसान है, लेकिन, सबसे पहले, इस तथ्य को नहीं कि यह आवश्यक होगा, और दूसरी बात, इस बारे में सोचें कि क्या यह सही निर्णय है। इस अवसर पर, फ्रेंडफीड (टोरनेडो डेवलपर्स) के लोगों ने एक से अधिक बार बात की है। उदाहरण के लिए, बेन डर्नेल की एक पोस्ट का एक उद्धरण है:

Friendfeed मानक तुल्यकालिक MySQLdb मॉड्यूल (http://bret.appspot.com/entry/how-friendfeed-use-mysql) के साथ mysql का उपयोग करता है। फ्रेंडफीड का दर्शन यह है कि उन चीजों के लिए जो तेज़ हैं और आपके नियंत्रण में हैं (यानी मेम्चे और डेटाबेस - और यदि आपका डेटाबेस तेज़ नहीं है, तो आप इसे कैसे क्वेरी कर रहे हैं, इस पर पुनर्विचार करें), आपको बस उन्हें समकालिक रूप से कॉल करना चाहिए क्योंकि यह जटिलता के लायक नहीं है कॉलबैक का प्रबंधन करना। एसिंक्रोनस कोड उन चीजों के लिए है, जो उन तरीकों से धीमा होने की संभावना है जिनके बारे में आप कुछ भी नहीं कर सकते हैं (जैसे बाहरी एपीआई) या जब आप अनिश्चित समय के लिए अनुरोध को स्थगित करना चाहते हैं (लंबे समय तक मतदान)। एक पुस्तकालय जैसा कि कुछ हद तक संतुलन को स्थानांतरित कर देता है क्योंकि यह async इंटरफेस का उपयोग करने के लिए बहुत सरल बनाता है, हालांकि इस तथ्य की तरह अभी भी मुद्दे हैं कि जनरेटर कोराउट सामान्य फ़ंक्शन कॉल की तरह रचना योग्य नहीं हैं।

यही है, मोटे तौर पर बोलना, अगर आपका डेटाबेस धीमा है, तो इसका मतलब है कि किसी भी मामले में सर्वर लोड का सामना नहीं कर सकते हैं, और अतुल्यकालिक स्टार्टअप यहां बहुत मदद नहीं करते हैं। , , — , , .

Tornado- management-. Django ORM .

management- . privatemessages management, commands.

privatemessages/management privatemessages/management/commands __init__.py ( - , , ).

privatemessages/management/commands/starttornadoapp.py:

 import signal import time import tornado.httpserver import tornado.ioloop from django.core.management.base import BaseCommand, CommandError from privatemessages.tornadoapp import application class Command(BaseCommand): args = '[port_number]' help = 'Starts the Tornado application for message handling.' def sig_handler(self, sig, frame): """Catch signal and init callback""" tornado.ioloop.IOLoop.instance().add_callback(self.shutdown) def shutdown(self): """Stop server and add callback to stop i/o loop""" self.http_server.stop() io_loop = tornado.ioloop.IOLoop.instance() io_loop.add_timeout(time.time() + 2, io_loop.stop) def handle(self, *args, **options): if len(args) == 1: try: port = int(args[0]) except ValueError: raise CommandError('Invalid port number specified') else: port = 8888 self.http_server = tornado.httpserver.HTTPServer(application) self.http_server.listen(port, address="127.0.0.1") # Init signals handler signal.signal(signal.SIGTERM, self.sig_handler) # This will also catch KeyboardInterrupt exception signal.signal(signal.SIGINT, self.sig_handler) tornado.ioloop.IOLoop.instance().start() 

, (, SIGINT, Ctrl + C) - , . .

चेक

( myproject privatemessages, manage.py) development- Django Tornado.

python manage.py runserver
python manage.py starttornadoapp

, screen (, , SSH SSH-).

8000 Django, 8888 Tornado.

:

http://127.0.0.1:8000/messages/

( ).

, Django-. , , . — प्रशासनिक इंटरफ़ेस सक्षम करें और इसके माध्यम से लॉग इन करें।

तैनाती

सर्वर पर अपना एप्लिकेशन चलाने के लिए, हम निम्नलिखित सॉफ़्टवेयर का उपयोग कर सकते हैं:

• haproxy - load balancer, पोर्ट 80 पर काम करेगा
• nginx - स्थिर फ़ाइलों का वितरण + gunicorn के लिए रिवर्स प्रॉक्सी, पोर्ट 8100 पर काम करेगा
• पर्यवेक्षक - बंदरगाहों पर 8000-8003 (4 प्रक्रियाएँ) और Django सर्वर (आप gunicorn का उपयोग कर सकते हैं) पर टॉरनेडो सर्वर शुरू करें 8150

Supervisor. ( Supervisor Ubuntu) /etc/supervisor/conf.d django.conf tornadoapp.conf. , Supervisor ( include files = /etc/supervisor/conf.d/*.conf).

django.conf

[program:django]
command=gunicorn_django --workers 4 -b 127.0.0.1:8150
directory=/home/yourusername/myproject
user=yourusername
autostart=true
autorestart=true

tornadoapp.conf

process_name = tornado-%(process_num)s
user = yourusername
directory = /home/yourusername/myproject
command = python manage.py starttornadoapp %(process_num)s
# Increase numprocs to run multiple processes on different ports.
# Note that the chat demo won't actually work in that configuration
# क्योंकि यह मानता है कि सभी श्रोता एक प्रक्रिया में हैं।
संख्या = 4
numprocs_start = 8000
ऑटोस्टार्ट = सत्य
autorestart = true

अब सुपरवाइज़र चलाएं और सुपरवाइज़रल स्टेटस कमांड का आउटपुट देखें।

सुनिश्चित करें कि सभी 5 प्रक्रियाओं (एक प्रक्रिया के रूप में अंगरखा प्रदर्शित किया जाएगा) एक रनिंग स्थिति को प्रदर्शित करता है और पर्यवेक्षक के शुरू होने के बाद कितना समय बीत चुका है, यह मेल खाता है।

मैं यह भी सुनिश्चित करने की सलाह देता हूं कि Django सर्वर और टॉरनेडो सर्वर दोनों काम कर रहे हैं। ऐसा करने के लिए, हम सर्वर पर SSH सुरंग खोल सकते हैं और स्थानीय पते पर चयनित पोर्ट तक पहुँचते हुए, ब्राउज़र में अपनी साइट खोलने का प्रयास कर सकते हैं।

उदाहरण के लिए, यह है:

ssh -L 8000: लोकलहोस्ट: 8150 someverycoolserver.com

127.0.0.1:8000 (SSH- 127.0.0.1:8150 — -, ).

Tornado-. 8000—8003.

Django Tornado , nginx haproxy.

nginx:

 सर्वर {
    listen 127.0.0.1:8100;
    server_name someverycoolserver.com;

    # no security problem here, since / is always passed to upstream
    root /home/yourusername/myproject/myproject/static/;

    ## Compression
    # src: http://www.ruby-forum.com/topic/141251
    # src: http://wiki.brightbox.co.uk/docs:nginx

     पर gzip;
    gzip_http_version 1.0;
    gzip_comp_level 2;
     gzip_proxied कोई भी;
    gzip_min_length 1100;
    gzip_buffers 16 8k;
    gzip_types text/plain text/html text/css application/x-javascript text/xml application/xml application/xml+rss text/javascript;
    
    # Some version of IE 6 don't handle compression well on some mime-types, so just disable for them
    gzip_disable "MSIE [1-6].(?!.*SV1)";
    
    # Set a vary header so downstream proxies don't send cached gzipped content to IE6
     gzip_vary पर;
    ## /Compression

    location /static/admin/ {
        # this changes depending on your python version
        root /usr/local/lib/python2.7/dist-packages/django/contrib/admin/;
     }

    location /robots.txt {
        alias /home/yourusername/myproject/myproject/robots.txt;
     }

    location /favicon.ico {
        alias /home/yourusername/myproject/myproject/img/favicon.ico;
        expires 3d;
     }

    location /static/ {
        root /home/yourusername/myproject/myproject/;
        expires 3d;
     }

    location / {
        proxy_pass_header Server;
        proxy_set_header Host $http_host;
        proxy_redirect off;
         प्रॉक्सी_सेट_हेडर एक्स-रियल-आईपी $ रिमोट_ड्रेड;
        proxy_set_header X-Scheme $scheme;
        proxy_connect_timeout 10;
        proxy_read_timeout 10;
        proxy_pass http://localhost:8150/;
     }
 }

, . , , ( - ), static files versioning ( , query string, , , query string ). , , () CSS JS — , django-assets .

haproxy:

global
    maxconn 10000 # Total Max Connections. This is dependent on ulimit
    nbproc 2

 चूक
    mode http
    option redispatch
    maxconn 2000
    contimeout 5000
    clitimeout 50000
    srvtimeout 50000
    option httpclose

frontend all 0.0.0.0:80
    timeout client 86400000

    acl is_chat hdr_beg(host) -i chat
    use_backend socket_backend if is_chat

    default_backend www_backend

backend www_backend
    option forwardfor # This sets X-Forwarded-For
    timeout server 30000
    timeout connect 4000
    server server1 localhost:8100

backend socket_backend
    balance roundrobin
    option forwardfor # This sets X-Forwarded-For
    no option httpclose # To match the `Connection` header for the websocket protocol rev.  76
    option http-server-close
    option http-pretend-keepalive
    timeout queue 5000
    timeout server 86400000
    timeout connect 86400000
    server server1 localhost:8000 weight 1 maxconn 5000 check
    server server2 localhost:8001 weight 1 maxconn 5000 check
    server server2 localhost:8002 weight 1 maxconn 5000 check
    server server2 localhost:8003 weight 1 maxconn 5000 check

, , Host chat, localhost:8000, localhost:8001, localhost:8002 localhost:8003, localhost:8100.

haproxy 80- IPv4-. IPv6 ( , /), frontend bind IPv6- 80- .

, IPv6- (, , AAAA- DNS), . , . — IPv6, DNS whitelisting . , , — IPv6, 1—2 ( ).

, Tornado- , — , ( 80 443).

haproxy , backend Host, Upgrade — , Django, Tornado ( ), WS- Tornado-, — Django-.

, . , , , ( Django Tornado ), , . ! .