पायथन के लिए Google ऐप इंजन पर चैनल एपीआई का उपयोग करके सरल चैट

मैं आपके लिए " चैनल एपीआई का उपयोग करके एक साधारण चैट " नामक लेख का मुफ्त अनुवाद प्रस्तुत करता हूं। मैंने अपना कोड थोड़ा जोड़ने का भी फैसला किया।

आज हम आपके लिए चैनल एपीआई के लिए समर्पित गूगल ऐप इंजन के लिए एक नया लेख प्रस्तुत करते हैं, जो दिसंबर 2010 में रिलीज 1.4 में दिखाई दिया। इस क्षण से, सर्वर से क्लाइंट और बैक पर बिना मतदान का उपयोग किए सीधे संदेश भेजना संभव हो गया।
इसलिए, Google App Engine पर चैट को लागू करना काफी सरल हो गया। कटौती के तहत कार्यान्वयन प्रक्रिया का वर्णन किया गया है।

आप http://chat-channelapi.appspot.com/ पर डेमो देख सकते हैं।
परियोजना कोड यहां डाउनलोड किया जा सकता है (मूल लेख से कोड यहां है )।

हमारे आवेदन में, उपयोगकर्ता और कार्यक्रम के बीच एक चैनल बनाने के लिए, आपको निम्नलिखित चरणों को लेने की आवश्यकता है, जो चित्र में नीचे दिखाया गया है।

कदम:
1) एप्लिकेशन चैनल आईडी (चैनल आईडी) और टोकन बनाता है और उन्हें क्लाइंट को भेजता है
2) क्लाइंट एक सॉकेट खोलने के लिए टोकन का उपयोग करता है जो चैनल को सुनेगा
3) क्लाइंट 2 अपनी अनूठी चैनल आईडी के साथ, एप्लिकेशन को एक चैट संदेश भेजता है
4) एप्लिकेशन सभी ग्राहकों को संदेश भेजता है जो सॉकेट के माध्यम से चैनल सुनते हैं। इसके लिए, प्रत्येक क्लाइंट की चैनल आईडी का उपयोग किया जाता है।

सभी चरणों का वर्णन करने से पहले, यह ध्यान दिया जाना चाहिए कि हमने डेटाबेस की इकाई को यथासंभव सरल बना दिया है जो कार्यक्रम में भाग लेंगे। हमने दो बनाए - उपयोगकर्ता मॉडल और संदेश।

class OnlineUser (db . Model):
nick = db . StringProperty(default = "" )
channel_id = db . StringProperty(default = "" )

class Message (db . Model):
text = db . StringProperty(default = "" )
user = db . ReferenceProperty(User)


कोड जीएई उपयोगिताओं पुस्तकालय में लागू सत्र तंत्र का भी उपयोग करता है। लेकिन सत्र पर ज्यादा ध्यान न दें।

चरण 1

इस चरण में, हमारा चैट एप्लिकेशन चैनल आईडी और टोकन बनाता है और उन्हें क्लाइंट को भेजता है। इस चरण के लिए कोड काफी सरल है। बस चैनल एपीआई आयात करने के लिए याद रखें:

from google.appengine.api import channel


उसके बाद, एक हैंडलर बनाएं जो प्रत्येक उपयोगकर्ता के लिए एक अद्वितीय आईडी बनाता है (हम uuid4 () फ़ंक्शन का उपयोग uuid मॉड्यूल से करेंगे)। निम्नलिखित हैंडलर बस यही करता है और ग्राहक को डेटा टेम्पलेट में भेजता है:

class ChatHandler (webapp . RequestHandler):
def get ( self ):
self . redirect( '/' )

def post ( self ):
# http://gaeutilities.appspot.com/
self . session = Session()
#
nick = self . request . get( 'nick' )
if not nick:
self . redirect( '/' )
# ,
user = OnlineUser . all() . filter( 'nick =' , nick) . get()
if user:
self . session[ 'error' ] = 'That nickname is taken'
self . redirect( '/' )
return
else :
self . session[ 'error' ] = ''
# id Channel API
channel_id = str (uuid . uuid4())
chat_token = channel . create_channel(channel_id)
#
user = OnlineUser(nick = nick,channel_id = channel_id)
user . put()
# 100
messages = Message . all() . order( 'date' ) . fetch( 1000 )
#
template_vars = { 'nick' :nick, 'messages' :messages, 'channel_id' :channel_id, 'chat_token' :chat_token}
temp = os . path . join(os . path . dirname(__file__), 'templates/chat.html' )
outstr = template . render(temp, template_vars)
self . response . out . write(outstr)


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

चरण 2

अब क्लाइंट टोकन निकालने और सॉकेट खोलने के लिए जिम्मेदार है। हम जावास्क्रिप्ट कोड को कम करने के लिए jQuery का उपयोग करते हैं। नीचे हमारा कोड है:

var chat_token = $( '#channel_api_params' ).attr( 'chat_token' );
var channel = new goog.appengine.Channel(chat_token);
var socket = channel.open();
socket.onopen = function (){
};
socket.onmessage = function (m){
var data = $.parseJSON(m.data);
$( '#center' ).append(data[ 'html' ]);
$( '#center' ).animate({scrollTop : $( "#center" ).attr( "scrollHeight" )}, 500 );
};
socket.onerror = function (err){
alert( "Error => " + err.description);
};
socket.onclose = function (){
alert( "channel closed" );
};


चरण 3

इस चरण पर, क्लाइंट 2 इंटरफ़ेस के माध्यम से हमारी चैट पर एक संदेश भेजता है। ऐसा करने के लिए, एक संदेश भेजने के लिए बस एक टेक्स्ट बॉक्स और एक बटन बनाएं। संदेश को एक सरल श्रोता का उपयोग करके जावास्क्रिप्ट कोड में भेजा जाएगा, जिसे हम jQuery का उपयोग करके लागू करते हैं। आप इसके बजाय या केवल XMLHttpRequest ऑब्जेक्ट का उपयोग करके किसी भी javsctipt लाइब्रेरी का उपयोग कर सकते हैं। बस ध्यान रखें कि आपको एप्लिकेशन में क्लाइंट की सही पहचान करने के लिए एक अद्वितीय क्लाइंट चैनल आईडी भेजना होगा।

$( '#send' ).click( function (){
var text = $( '#text' ).val();
var nick = $( '#nick' ).attr( 'value' );
var channel_id = $( '#channel_api_params' ).attr( 'channel_id' );
$.ajax({
url : '/newMessage/' ,
type : 'POST' ,
data : {
text : text,
nick : nick,
channel_id : channel_id,
},
success : function (data){
},
complete : function (){
}
});
});


चरण 4

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

class NewMessageHandler (webapp . RequestHandler):
def post ( self ):
#
text = self . request . get( 'text' )
channel_id = self . request . get( 'channel_id' )
q = db . GqlQuery( "SELECT * FROM OnlineUser WHERE channel_id = :1" , channel_id)
nick = q . fetch( 1 )[ 0 ] . nick
date = datetime . datetime . now()
#
message = Message(user = nick,text = strip_tags(text), date = date, date_string = date . strftime( "%H:%M:%S" ))
message . put()
#
messages = [message]
template_vars = { 'messages' :messages}
temp = os . path . join(os . path . dirname(__file__), 'templates/messages.html' )
outstr = template . render(temp, template_vars)
channel_msg = json . dumps({ 'success' : True , "html" :outstr})
#
users = OnlineUser . all() . fetch( 100 )
for user in users:
channel . send_message(user . channel_id, channel_msg)


वैकल्पिक कदम

इस स्तर पर, मूल लेख समाप्त हो जाता है, लेकिन मैं अगले कार्य से संबंधित कोड में कुछ बदलाव करना चाहता था। मूल लेख में, उपयोगकर्ता नाम चैट में प्रवेश करने के बाद ब्लॉक किए जाते हैं और आप इस उपनाम का उपयोग करके लॉग इन नहीं कर सकते। हम इस प्रतिबंध को हटाते हैं। ऐसा करने के लिए, कुंजी समाप्त होने के बाद डेटाबेस से उपयोगकर्ता डेटा हटाएं। कुंजी तब तक समाप्त हो जाती है जब तक कि दो घंटे बीत चुके होते हैं, या जब तक ग्राहक सॉकेट पर बंद () फ़ंक्शन को कॉल नहीं करता। तब / _ah / चैनल / डिस्कनेक्ट / में पंजीकृत हैंडलर कहा जाता है। हम ऐसे हैंडलर लिखेंगे।

class ChannelDisconnectHandler (webapp . RequestHandler):
def post ( self ):
channel_id = self . request . get( 'from' )
q = OnlineUser . all() . filter( 'channel_id =' , channel_id)
users = q . fetch( 1000 )
db . delete(users)


जावास्क्रिप्ट कोड में, उस घटना का प्रसंस्करण जोड़ें जो तब होता है जब उपयोगकर्ता इस पृष्ठ को छोड़ता है:

$( window ).unload( function (){
socket.close();
});


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

class OnlineUser (db . Model):
nick = db . StringProperty(default = "" )
channel_id = db . StringProperty(default = "" )
creation_date = db . DateTimeProperty(auto_now_add = True )
opened_socket = db . BooleanProperty(default = False )


अब हमारे पास रिकॉर्ड (निर्माण_डेट) बनाने के लिए समय है और चैनल के खुलने के बारे में क्लाइंट से पुष्टि (ओपन_सोकेट) आ गई है। जब चैनल की ओर से चैनल.ओपन () कॉल करके क्लाइंट की तरफ से एक चैनल खोला जाता है, तो / _ah / चैनल / कनेक्ट / से पंजीकृत हैंडलर कहा जाता है। यह हैंडलर उपयोगकर्ता को चैनल खोलने की पुष्टि करने के लिए उजागर करेगा:

class ChannelConnectHandler (webapp . RequestHandler):
def post ( self ):
channel_id = self . request . get( 'from' )
q = OnlineUser . all() . filter( 'channel_id =' , channel_id)
user = q . fetch( 1 )[ 0 ]
user . opened_socket = True
user . put()


यह कोड पहचान के लिए चैनल आईडी को सर्वर पर भेजता है। हैंडलर नीचे प्रस्तुत किया गया है:

class RegisterOpenSocketHandler (webapp . RequestHandler):
def post ( self ):
channel_id = self . request . get( 'channel_id' )
q = OnlineUser . all() . filter( 'channel_id =' , channel_id)
user = q . fetch( 1 )[ 0 ]
user . opened_socket = True
user . put()


अंतिम चरण क्रोन हैंडलर का उपयोग शुरू करने के लिए होगा, जो OnlineUser उपयोगकर्ता मॉडल से सभी प्रविष्टियों का चयन करेगा, जिसमें चैनल के खुलने की पुष्टि होगी और वर्तमान से निर्माण का समय 120 सेकंड से अधिक होगा:

class ClearDBHandler (webapp . RequestHandler):
def get ( self ):
q = OnlineUser . all() . filter( 'opened_socket =' , False )
users = q . fetch( 1000 )
for user in users:
if ((datetime . datetime . now() - user . creation_date) . seconds > 120 ):
db . delete(user)


अंत में

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

PS अनुप्रयोग के वास्तविक कार्य से पता चला कि संदेशों को फ़िल्टर करना आवश्यक है, उनमें से html टैग को छोड़कर। ऐसा करने के लिए, django ढांचे से strip_tags फ़ंक्शन आयात करें:

from django.utils.html import strip_tags


नए संदेश हैंडलर (NewMessageHandler) में, हम निम्नलिखित के साथ एक नया संदेश बनाने के लिए कोड को प्रतिस्थापित करते हैं:

message = Message(user = nick,text = strip_tags(text), date = date, date_string = date . strftime( "%H:%M:%S" ))