तूफान वेब में अनुरोधों के बीच डाटा साझा करने के लिए कैसे

Question

मैं अपने तूफान वेब सर्वर के लिए निम्नलिखित का उपयोग मामला है:

पोस्ट अनुरोध प्रविष्टियों सर्वर से बनाया जा सकता है पर, प्रविष्टियों जो एक फ़ाइल या डेटाबेस के लिए कायम नहीं की जाएगी । अनुरोध प्राप्त करने पर एक प्रक्रिया शुरू या समाप्त की जा सकती है।

इसलिए मुझे अपने RequestHandler कार्यान्वयन में विभिन्न अनुरोधों के बीच डेटा साझा करने की आवश्यकता है। ऐसा करने का सामान्य तरीका क्या है?

मुझे पर डेटा सहेजने में कठिनाई थी, उदाहरण के लिए self.entry = "..."। एक अन्य अनुरोध में डेटा अब मौजूद नहीं था।

केवल काम कर समाधान मैंने पाया स्टोर करने के लिए है कि आवेदन वस्तु में है:

application = web.Application([ 
      (r'.*', MainHandler, 
      ]) 

और

def get(self): 
     # ... 
     self.application.entry = "..." 

कि उचित तरीका है? यहां सिंक्रनाइज़ेशन के बारे में भी, मेरा मतलब है कि इसका मतलब साझा डेटा तक पहुंच है।

Answer 1

मैं निम्नलिखित सुझाव: एक डेटाबेस का उपयोग वस्तु के बजाय उदाहरण के लिए, एक वस्तु जो आपके डेटा को संगृहीत पारित:

data = DataStore() 

application = web.Application([ 
     (r'.*', MainHandler, dict(data = data), 
     ]) 

निम्नलिखित RequestHandler प्रारंभ विधि के साथ

।

def initialize(self, data): 
    self.data = data 

आपको ऑब्जेक्ट बनाने से पहले इसे पास करना होगा, अन्यथा यह अनुरोध हर बार संसाधित हो जाएगा।

Answer 2

आप इस तरह के कुछ के लिए memcached का उपयोग कर सकते हैं। हालांकि, आपको memcached सर्वर सेट अप करने की आवश्यकता होगी।

http://pypi.python.org/pypi/python-memcached/

Answer 3

आवेदन की दुकान (अर्ध) लगातार डेटा का अधिकार वस्तु है। हालांकि, जैसा कि अन्य anwser पर सुझाया गया है, आपको इस डेटा को स्टोर करने के लिए किसी प्रकार का डेटाबेस उपयोग करने पर विचार करना चाहिए।

हालांकि, आपको ध्यान रखना चाहिए कि एक सत्र (या लेनदेन) ठीक से खत्म नहीं होता है (उदाहरण के लिए आपको एक पोस्ट मिलता है लेकिन कार्रवाई को ट्रिगर करने के लिए कोई भी प्राप्त नहीं होता है), आपको सत्र डेटा को हटाना चाहिए ताकि आपके पास न हो वेबसर्वर रिसाव स्मृति।

मेरे अनुभव से, मैं Redis का उपयोग करने का सुझाव देना चाहता हूं क्योंकि इसका उपयोग करना आसान है और key expiration का समर्थन करता है, एक तंत्र जो सत्र डेटा प्रबंधित करने की आवश्यकता होने पर आसान होता है।

class MyHandler(RequestHandler): 
    def initialize(self, database): 
     self.database = database 

    def get(self, username): 
     ... 

mydatabase = dict() 

app = Application([ 
    (r'/user/(.*)', MyHandler, dict(database=mydatabase)), 
    ]) 

तो फिर तुम एक फाइल करने के लिए अपने ऑब्जेक्ट mydatabase बचा सकते हैं:

Answer 4

documentation एक तरह से यह करने के लिए देता है।

लेकिन मुझे यकीन नहीं है कि अनुरोधों के बीच सिंक्रनाइज़ेशन के संबंध में आप जो हासिल करना चाहते हैं, उसे हासिल करने का यह सही तरीका है।