Sessions: FilesystemStore में रेस की स्थिति

ताला लगाने के बजाय, लेनदेन आधारित प्रणाली के बारे में क्या? सत्र ऑब्जेक्ट एक lastModified फ़ील्ड ले जा सकता है। जब आप सत्र को वापस सत्र संग्रह में सहेजने का प्रयास करते हैं, तो यह एक त्रुटि लौटाएगा यह दर्शाता है कि इसे अंतिम बार पढ़ने के बाद संशोधित किया गया है। प्रोग्रामर फिर सेशन प्राप्त करके पुन: प्रयास करना चुन सकता है।

यह काम कर सकता है, इसका यह फायदा है कि ऐसे ताले नहीं होते जिन्हें साफ करने की जरूरत होती है और गतिरोध का कोई मौका नहीं होता। मुझे यकीन नहीं है कि डेवलपर्स के लिए यह हमेशा संभव है कि जो अनुरोध पहले ही किया गया है उसके आधार पर एक सार्थक वापसी करें। मुझे लगता है कि लॉकिंग निश्चित रूप से सुरक्षित विकल्प है, लेकिन लेनदेन निश्चित रूप से काम कर सकता है अगर एपीआई स्पष्ट रूप से विफलता के लिए मौका देता है और अगर डेवलपर्स पूरी मेहनत से उन त्रुटियों को संभालते हैं।

उस ने कहा, भले ही FilesystemStore लेनदेन का उपयोग करता हो, मुझे लगता है कि एपीआई को स्टोरेज बैकेंड के लिए तैयार रहना चाहिए जो _do_ लॉकिंग का उपयोग करता है, लेकिन इसका मतलब होगा कि session.Save() एक बार से अधिक session.Release() शुरू करने का मतलब है

इस मुद्दे के बाद से यह RediStore को प्रभावित करता है। जानकारी के लिए धन्यवाद @cless

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

क्या आपके पास अन्य सत्र ढांचे के कोई उदाहरण हैं जो इस समस्या को हल करते हैं? मैं यह देखने के लिए उत्सुक हूं कि वे क्या करते हैं।

मुझे पता है कि डिफ़ॉल्ट php सेशन हैंडलर फाइलसिस्टम आधारित लॉकिंग का उपयोग करता है (php 5.4 टारबॉल में मैंने अभी चेक किया है यह ext/session/mod_files.c । यह झुंड का उपयोग करता है जो ext/standard/flock_compat.c द्वारा प्रदान किया जाता है)।

मुझे यकीन नहीं है कि अगर php एक अच्छा उदाहरण है जो इसे प्रतिष्ठा देता है, लेकिन मुझे डर है कि यह एकमात्र ऐसा क्षण है जिसके बारे में मुझे पता है। मैं देखने के लिए चारों ओर एक नज़र रखने की कोशिश करूँगा कि क्या मुझे कुछ अन्य रूपरेखाएँ मिल सकती हैं और वे इस मुद्दे को कैसे हल कर सकते हैं।

मैं यह देखने के लिए उत्सुक हूं कि फ्लास्क, पिरामिड या Django इन चीजों को कैसे संभालते हैं। अगर मेरे पास समय है तो मैं उन पर एक नज़र डालूंगा। यदि कोई उस कोडबेस से परिचित है तो रेल भी दिलचस्प होगी।

पिरामिड और फ्लास्क दोनों डेटा को संग्रहीत करने के लिए कुकी का उपयोग करते हुए प्रतीत होते हैं, मुझे संदेह है कि न तो दौड़ की स्थिति को संभालता है। मैंने केवल संक्षेप में प्रलेखन पढ़ा है इसलिए मैं बहुत अच्छी तरह से गलत हो सकता हूं।

Django सर्वर साइड सत्र डेटा का समर्थन करता है इसलिए मैं उस कोड को थोड़ा देखूंगा।

डिफ़ॉल्ट Django सत्र बैकएंड डेटाबेस है और यह Django डेटाबेस अमूर्त परत का उपयोग करता है जिससे मैं अपरिचित हूं, इसलिए यह व्याख्या करना मेरे लिए कठिन है। हालाँकि, मुझे यह टिप्पणी फाइलसिस्टम बैकएंड में मिली:

        # Write the session file without interfering with other threads
        # or processes.  By writing to an atomically generated temporary
        # file and then using the atomic os.rename() to make the complete
        # file visible, we avoid having to lock the session file, while
        # still maintaining its integrity.
        #
        # Note: Locking the session file was explored, but rejected in part
        # because in order to be atomic and cross-platform, it required a
        # long-lived lock file for each session, doubling the number of
        # files in the session storage directory at any given time.  This
        # rename solution is cleaner and avoids any additional overhead
        # when reading the session data, which is the more common case
        # unless SESSION_SAVE_EVERY_REQUEST = True.
        #
        # See ticket #8616.

इससे यह प्रतीत होता है कि वे यह सुनिश्चित करते हैं कि सत्र की फ़ाइल सामग्री कभी मंगाई नहीं गई है, लेकिन ऐसा नहीं है कि कोई दौड़ की स्थिति नहीं हो सकती है। अगर किसी को भी Django का अनुभव है, तो क्लैस / सेशन @ f84abed जैसा टेस्ट केस देखना अच्छा होगा
Stackoverflow भी इंगित करता है कि Django सत्रों में दौड़ की स्थिति हो सकती है: http://stackoverflow.com/search?q=django+session+race+condition

ठीक है, अच्छी तरह से FileSystemStore में पहले से ही सत्र की दुकान के भ्रष्टाचार को रोकने के लिए एक मोटे दाने वाला म्यूटेक्स है। मुझे यकीन नहीं है कि लाइब्रेरी में डालने के लिए कितना अतिरिक्त सुरक्षा है क्योंकि यह हर अनुरोध के लिए बहुत अधिक ओवरहेड जोड़ देगा, बस कुछ अनुरोधों के लिए चीजों को अधिक सुसंगत बनाने के लिए। निश्चित रूप से यहां का परिदृश्य संभव है, लेकिन मुझे लगता है कि सामान्य ज्ञान से निपटने के लिए शायद यह बहुत जटिल है। मैं देख सकता हूं कि ऐसे कई मामले हैं जहां अब जो होता है वह पूरी तरह से ठीक है, जबकि कुछ अनुप्रयोगों में यह एक समस्या हो सकती है। मुझे सबसे अधिक संदेह है कि आपके पास किसी दिए गए सत्र के लिए वैसे भी केवल एक इन-फ्लाइट अनुरोध होगा।

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

वैसे भी, इस समय मेरे विचार हैं, लेकिन मुझे आगे चर्चा करने में खुशी हो रही है।

ऐसा लगता है कि लंबे समय में यह एक एप्लिकेशन डोमेन समस्या से अधिक है।

परिदृश्य क्लैस को पोस्ट किए जाने पर, यदि अनुरोध 1 से लंबे समय तक चलने की उम्मीद है, तो अनुरोध 2 समानांतर में हो सकता है (जैसे कि, Angular.js, या एक अतुल्यकालिक नोड.जेएस ऐप जो कुछ एपीआई मार रहा है) में लिखा एक एकल पृष्ठ अनुप्रयोग, ऐसा लगता है। लंबे समय से चल रहे अनुरोध को सत्र से हटा दिया जाना चाहिए और उस बिंदु पर एक स्वतंत्र कार्यकर्ता प्रक्रिया पर विचार किया जाना चाहिए।

इसमें से कोई भी पाठ्यक्रम के मुद्दे को सीधे संबोधित नहीं करता है, लेकिन जैसा कि किसलिक ने उल्लेख किया है, किसी भी तरह का ताला लगाने से सीमांत मामला प्रतीत होता है।

सत्र दौड़ की स्थितियों के प्रभाव के कुछ वास्तविक विश्व उदाहरण यहां दिए गए हैं। बग को डिबग करना मुश्किल है, यादृच्छिक रूप से दिखते हैं और डेवलपर्स और उपयोगकर्ताओं दोनों के लिए एक गुस्सा है। पर्याप्त रूप से बड़े अनुप्रयोग को देखते हुए जो कि अजाक्स का व्यापक उपयोग करता है, ये दौड़ की स्थिति जल्द या बाद में दिखाई देगी।
http://www.hiretheworld.com/blog/tech-blog/codeigniter-session-race-conditions
http://www.chipmunkninja.com/Troubles-with-Asynchronous-Ajax-Requests-g@

मैंने एलिसलैब / कोडइग्निटर # 1746 में पूरे सूत्र को पढ़ा है जो एक समान मुद्दे से संबंधित है, लेकिन उनका मुद्दा इस तथ्य से जटिल है कि कोडआईग्निटर हर बार एक बार सत्र आईडी को फिर से बनाता है और अधिकांश चर्चा इस तथ्य के इर्दगिर्द घूमती है। ।

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

type Store interface {
    Get(r *http.Request, name string) (*Session, error)
    New(r *http.Request, name string) (*Session, error)
    Save(r *http.Request, w http.ResponseWriter, s *Session) error
    Lock(r *http.Request, name string) error
    Release(r *http.Request, name string) error
}

इन कार्यों का उपयोग पूरी तरह से वैकल्पिक होगा (हालांकि मैं व्यक्तिगत रूप से सत्र के लिए लिखने वाले हर अनुरोध में लॉकिंग को प्रोत्साहित करूंगा) और मौजूदा अनुप्रयोगों पर कोई प्रभाव नहीं पड़ेगा।

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

क्षमा करें, जब मैंने अपना पोस्ट किया तो मुझे बोज का उत्तर याद आ गया:
यह ध्यान रखना महत्वपूर्ण है कि दौड़ की स्थिति को ट्रिगर करने के लिए लंबे समय तक चलने वाले अनुरोधों की आवश्यकता नहीं है। मेरे परीक्षण के मामले में 500 एमएस नींद केवल यह सुनिश्चित करने के लिए है कि दौड़ की स्थिति को ट्रिगर किया गया है। वास्तविक दुनिया में ये दौड़ स्थितियां "कम" अनुरोधों के लिए घटित होंगी, बस कम बार, और यही वास्तव में उन्हें डीबग करना कठिन बनाता है।

आपको यह भी ध्यान रखना होगा कि उच्च लोड के तहत भी कम अनुरोधों को निष्पादित होने में कुछ समय लग सकता है।

@ बिना अच्छे अंक।

मुझे आपके प्रस्तावित इंटरफ़ेस में बदलाव पसंद हैं।

RediStore के लिए आपका ताला समाप्त होना अपेक्षाकृत आसान होगा, Redis में एक EXPIRE कमांड है जो TTL को एक कुंजी के लिए सेट करने की अनुमति देता है।

क्या इस तरह के महीन दाने वाले लॉकिंग अभी भी कई प्रकार के सत्र भंडारों के लिए पर्याप्त रूप से अक्षम नहीं होंगे? और समाप्ति एक मुद्दा भी है।

ऐसा लगता है कि समस्या यह है कि यदि सत्र अधिक समय तक रहता है, तब भी सहेजें सफल हो सकता है, क्या समस्या के समाधान की दिशा में यह एक लंबा रास्ता तय नहीं करेगा, अगर ऐसा नहीं होता?

@kisielk , क्या आप उन दुकानों के उदाहरण दे सकते हैं जो अक्षम होंगे? अधिकांश कुंजी-मूल्य डेटाबेस में कुछ प्रकार के परमाणु संचालन होते हैं जो आपको ताले बनाने की अनुमति देते हैं। SQL डेटाबेस में आमतौर पर पंक्ति आधारित लॉकिंग तक पहुंच होती है (हालांकि मुझे कहना होगा कि मैं यहां के विवरण से परिचित नहीं हूं)।
की-वैल्यू स्टोर की लॉकिंग विधि जैसे रेडिस को डेटाबेस के लिए कई राउंड ट्रिप की आवश्यकता होती है, शायद यह वही है जो आपका मतलब था?
फ़ाइल सिस्टम स्टोर के साथ एक समस्या है क्योंकि गो हमें फ़ाइल लॉक तक पहुंचने के लिए एक क्रॉस प्लेटफ़ॉर्म तरीका प्रदान नहीं करता है। मुझे लगता है कि कोगो आपको मुख्य प्लेटफॉर्म का समर्थन करने वाले को बनाने की अनुमति देगा, लेकिन यह शायद एक ऐसा समाधान है जिससे मैं बचूंगा।

मुझे नहीं लगता कि जब सत्र अब मौजूद नहीं है तो बचत करना एक वास्तविक मुद्दा है जब तक कि आप वर्तमान सत्र को हटाने और सत्र निर्धारण को रोकने के लिए नए सत्र के साथ इसे बदलने की बात नहीं कर रहे हों, लेकिन ईमानदार होना एक पूरी तरह से अलग समस्या है।

@boj , मुद्दा यह है कि प्रोग्रामर को यह सत्यापित करने के लिए किसी तरह की आवश्यकता है कि लॉक को बचाने की कोशिश करने से पहले अभी तक समाप्त नहीं हुआ है। एक ताला पर समाप्ति का समय क्या होना चाहिए?

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

func Lock(expiration time.Duration) time.Time {
    // Block here until the lock becomes your. Set the lock to expire after
    // dur+50ms. This extra 50 ms ensures that you never assume you own an
    // expired lock
    return time.Now().Add(expiration)
}

func main() {
    end := Lock(1000 * time.Millisecond)

    // Do your thing here ...
    // time.Sleep(1100 * time.Millisecond)

    if time.Now().After(end) {
        fmt.Println("Lock expired, throw an error")
    } else {
        fmt.Println("Good to go, save the session")
    }
}

@ जब तक आपकी पूरी टिप्पणी इस तरह की हो जाती है, जो @kisielk की चिंता लगती है। एक्स ऐसा करता है, वाई करता है कि, जेड संभव नहीं हो सकता है जब तक कि कुछ चरम शामिल न हों। जबकि दौड़ की स्थिति वांछनीय नहीं है, क्योंकि वे दुर्लभ मामले हो सकते हैं, कम से कम वर्तमान गोरिल्ला / सत्र डिजाइन बहुत सरल है और कम से कम आश्चर्य दर्शन के तत्व का अनुसरण करता है।

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

यहां प्रति-सत्र लॉकिंग की बारीकियों के बारे में एक अच्छा लेख है:

http://thwartedefforts.org/2006/11/11/race-conditions-with-ajax-and-php-sive/

जैसा कि हमने पहले ही निष्कर्ष निकाला है कि अगर कुछ गलत हो जाता है तो ताले के लिए समय समाप्त हो जाता है। इसके लिए और अधिक विचार की आवश्यकता है और यह बहुत बैकेंड पर निर्भर है

जहां तक ​​लॉक / रिलीज को लागू करने का सवाल है, हम एक अलग इंटरफ़ेस होने के कारण प्रति-सत्र लॉक कार्यान्वयन को वैकल्पिक बना सकते हैं। बैकएंड को तब उस इंटरफ़ेस के खिलाफ बताया जा सकता है और अगर यह इसे लागू नहीं करता है तो हम इन-मेमोरी लॉक का उपयोग करके डिफ़ॉल्ट कार्यान्वयन प्रदान कर सकते हैं।

पाठ्यक्रम का एक और मुद्दा यह है कि लाइब्रेरी के उपयोगकर्ताओं को लॉक और रिलीज़ का उपयोग करने के लिए अपने कोड को अपडेट करने की आवश्यकता होगी, लेकिन मुझे लगता है कि इसके बिना उनके पास वैसा ही व्यवहार होगा जैसा वे अब करते हैं।

"हम इन-मेमोरी लॉक्स का उपयोग करके एक डिफ़ॉल्ट कार्यान्वयन प्रदान कर सकते हैं"

यह बहु-सर्वर वातावरण में अर्थहीन होगा जहां अनुरोध संतुलित होते हैं।

मुझे लॉकिंग के लिए एक पूरी तरह से अलग इंटरफ़ेस प्रदान करने का विचार पसंद है क्योंकि यह आपको सत्र का उपयोग करने वाले मौजूदा कोड के व्यवहार को बदलने के बिना इसे सही ढंग से लागू करने की अधिक स्वतंत्रता देता है।

जैसा कि @boj ने उल्लेख किया है कि आप किसी भी सार्थक तरीके से डेटाबेस स्टोर पर मेमोरी लॉक प्रदान नहीं कर सकते हैं। लॉक की कार्यक्षमता प्रदान करने का भार संभवतः स्टोर डेवलपर पर होना चाहिए। यदि ताले इंटरफ़ेस गायब है, तो आप अभी भी त्रुटियों को वापस कर सकते हैं जब सत्र उनका उपयोग करने की कोशिश करता है। यह वास्तव में एक समस्या नहीं होनी चाहिए, यदि डिफ़ॉल्ट स्टोर लॉकिंग प्रदान करते हैं, तो अन्य डेवलपर्स सूट का पालन करेंगे और उपयोगकर्ता न्यूनतम रूप से, यदि बिल्कुल भी असुविधाजनक हो तो।

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

@boj : सहमत हैं, लेकिन @cless के रूप में

मैं @cless से पूरी तरह सहमत हूं और सत्र लॉकिंग और परिपक्व प्लेटफार्मों के महत्व पर जोर देना चाहता हूं (जैसे PHP) इसे अपने सत्र भंडार पर लागू करते हैं। फ़ाइलों पर यह 'फ्लॉक' syscall और मेकचे में 'ऐड' ऑपरेशन के रिटर्न मूल्य और '.lock' प्रत्यय के साथ एक अतिरिक्त कुंजी और एक एक्सपायर सेट का उपयोग करके। मैं एक नए इंटरफ़ेस के लिए @kisielk के दृष्टिकोण से भी सहमत हूं (फ़ंक्शन 'लॉक' और 'रिलीज़' होने का अर्थ है) क्या हमारे पास यह हो सकता है? उच्च प्रदर्शन और विश्वसनीयता के लिए जाने के लिए भाषा होनी चाहिए। उदाहरण के लिए कुछ कार्यान्वयन (फाइलसिस्टम, रेडिस और मेम्चे) का योगदान करने के लिए तैयार। ध्यान दें कि हमें कुछ नए कॉन्फ़िगरेशन विकल्पों की आवश्यकता है:

• spinLockWait: लॉक हासिल करने के प्रयासों के बीच सोने के लिए मिलीसेकंड (डिफ़ॉल्ट: 150)
• LockMaxWait: सेकंड्स के लिए प्रतीक्षा करने के लिए लॉक (डिफ़ॉल्ट: 30)
• LockMaxAge: सेकंड लॉक को स्वचालित रूप से रिलीज़ होने से पहले रखा जा सकता है (डिफ़ॉल्ट: lockMaxWait)

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