वास्तविक समय के सहयोग के दौरान कैसे बचत करें

Question

मैं एकाधिक उपयोगकर्ताओं को एक ही दस्तावेज़ संपादित करना चाहता हूं। समस्या यह है कि जब एक नया उपयोगकर्ता जुड़ता है, तो वह एक पुराना दस्तावेज़ देख सकता है। मैं यह कैसे सुनिश्चित करूं कि नए उपयोगकर्ताओं को सबसे हाल के बदलाव मिले?

कुछ समाधान मैंने सोचा:

• हर बदलाव पर बचत करें। मुझे यह समाधान पसंद नहीं है क्योंकि यह UI पर चीजों को धीमा कर देगा और db पर लोड डाल देगा।

• जब नया उपयोगकर्ता जुड़ता है, तो अन्य सभी क्लाइंट पर ट्रिगर को सहेजें। अन्य ग्राहकों को बचाने के बाद, दस्तावेज़ लोड करें। इसके साथ अभी भी असंगति हो सकती है।

कोई अन्य सुझाव मददगार होगा।

अद्यतन: सुझाए गए समाधान, Google रीयलटाइम एपीआई को देखने के बाद, मुझे पता चला कि:

1. आपके ऐप के उपयोगकर्ताओं के पास Google ड्राइव होना चाहिए और आपको उनकी ड्राइव तक पहुंच प्रदान करनी चाहिए । यह सबसे अच्छी तरह से अजीब यूआई प्रवाह पर मौजूद हो सकता है या उन उपयोगकर्ताओं को रोक सकता है जिनके पास रीयल टाइम सुविधा का उपयोग करने से Google ड्राइव नहीं है।

2. आपकी ओर से की जाने वाली सभी साझाकरण सेटिंग को Google दस्तावेज़ के लिए दोहराया जाना है ।

अद्यतन 2: लक्ष्य को पूरा करने के लिए, मैं Google के फायरबेस के साथ गया

Comments

नए उपयोगकर्ता और पहले से सक्रिय उपयोगकर्ताओं के बीच एक ही दस्तावेज़ को संपादित / देखने में अंतर क्यों है?

— एंडी

@ और मैं वर्तमान में जो कर रहा हूं वह उन सभी परिवर्तनों को प्रसारित कर रहा है जो उपयोगकर्ता करते हैं। ये परिवर्तन उन उपयोगकर्ताओं के लिए UI अपडेट करते हैं जिनके ब्राउज़र खुले हैं, लेकिन वे डेटाबेस में तुरंत सहेजे नहीं जाते हैं। इसलिए मेरे पास एक स्थिति है, जब एक नया उपयोगकर्ता जुड़ता है, तो वह डेटाबेस से दस्तावेज़ लोड करता है और वह उन सभी हाल के परिवर्तनों को नहीं देखता है जो अभी तक सहेजे नहीं गए थे।

— dev.e.loper

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

— Dainius

Answer 1

गूगल ड्राइव

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

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

गैर-Google ड्राइव

तो आपके शोध के अनुसार, Google ड्राइव एक विकल्प नहीं है। यह ठीक है, लेकिन यह कठिन होने जा रहा है और संभवत: यह भी काम नहीं करता है कि आप इसमें कितना डालते हैं।

इस समस्या को पूरा करने के लिए मैं एक सामान्य रणनीति का उपयोग करूंगा:

1. क्या सर्वर संचार मल्टीप्लेक्सर है। प्रत्येक व्यक्ति सर्वर से बात करता है, और सर्वर उस जानकारी को अन्य सभी को भेजता है। इस तरह से सर्वर में हमेशा दस्तावेज़ को देखने के लिए सबसे अधिक होता है।

2. संघर्ष समाधान के लिए एक तृतीय पक्ष एल्गोरिदम / मॉड्यूल का पता लगाएं। संघर्ष संकल्प कठिन है, और कुछ है जो अभी भी सही नहीं है। ऐसा करने से परियोजना का दायरा बहुत बड़ा हो सकता है। यदि आप किसी तीसरे पक्ष के एल्गोरिथ्म का उपयोग नहीं कर सकते हैं, तो मेरा सुझाव है कि आप केवल एक उपयोगकर्ता को एक समय के क्षेत्र को संपादित करने की अनुमति दें, ताकि उपयोगकर्ता को किसी क्षेत्र को संपादित करने से पहले एक ताला प्राप्त करना पड़े, या आप किसी अन्य उपयोगकर्ता के काम को नष्ट करने का जोखिम उठाएं, जो बहुत जल्दी बूढ़ा हो जाएगा।

3. जब कोई नया उपयोगकर्ता जुड़ता है, तो उन्हें सबसे हालिया दस्तावेज़ दें और स्वचालित रूप से उनके लिए कमांड को स्ट्रीम करना शुरू करें। सर्वर के पास सबसे हाल का दृश्य है और इस प्रकार वह इसे स्वचालित रूप से हटा सकता है।

4. निश्चित अंतराल पर डेटाबेस का बैकअप। यह तय करें कि आप कितनी बार बैकअप लेना चाहते हैं (प्रत्येक 5 मिनट या शायद हर 50 परिवर्तन।) यह आपको बैकअप को आपकी इच्छा को बनाए रखने की अनुमति देता है।

समस्याएँ: यह एक सही समाधान नहीं है, इसलिए यहाँ कुछ मुद्दे हैं जिनका आपको सामना करना पड़ सकता है।

1. सर्वर के थ्रूपुट प्रदर्शन में बाधा डाल सकते हैं

2. बहुत अधिक पढ़ने / लिखने वाले लोग सर्वर को अधिभारित कर सकते हैं

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

Comments

हां, परिवर्तन सभी ग्राहकों के लिए प्रसारित किए जाते हैं और ब्राउज़र पर उनका (उम्मीद के समान) संस्करण होता है। लगता है जैसे आप कह रहे हैं कि, हर कार्रवाई पर दस्तावेज़ को अपडेट करना, जाने का एक तरीका है?

— dev.e.loper

या कम से कम नियमित रूप से 'सिंक' टाइमफ्रेम हैं जहां दस्तावेज़ की वर्तमान स्थिति को पृष्ठभूमि में प्रसारित किया जाता है ताकि यह सुनिश्चित हो सके कि हर कोई एक ही पृष्ठ पर है। कितनी बार इस बात पर निर्भर करेगा कि लोग दस्तावेज़ को कितनी तेज़ी से बदल रहे होंगे। इस तरह आपके पास नए लोगों को भेजने के लिए पहले से ही एक स्थापित तरीका है, साथ ही यह सुनिश्चित करने की क्षमता है कि यह कभी भी बहुत अधिक नहीं बदलता है।

— Ampt

+1। जीवन को कठिन मत बनाओ। पहिया को सुदृढ़ किए बिना Google यह अच्छी तरह से करता है।

— नील

क्या Google रीयलटाइम Google ड्राइव को बचाता है? मैं अपने डेटाबेस को सहेजना चाहता हूं, न कि Google ड्राइव को।

— dev.e.loper

@ dev.e.loper ने आपके लिए उत्तर के बारे में कुछ जानकारी जोड़ी है।

— अंप

Answer 2

मैं सर्वर पर दस्तावेज़ की 1 लगातार प्रतिलिपि बनाने की सलाह दूंगा। जब कोई क्लाइंट सर्वर से जुड़ता है तो आप UPDATEउस ग्राहक को सभी परिवर्तनों के साथ एक कमांड जारी करते हैं।

वर्कफ़्लो अपडेट करें

उपयोगकर्ता परिवर्तन का कारण बनता है -> क्लाइंट UPDATEसर्वर को भेजता है -> सर्वर UPDATEग्राहकों को भेजता है

व्यवहार्य ट्रिगर

1. उपयोगकर्ता क्लिक सहेजें
2. उपयोगकर्ता एक विशिष्ट कार्य पूरा करता है
   • एक सेल का संपादन करता है
   • एक वाक्य / पैराग्राफ / पंक्ति के संपादन को समाप्त करता है
3. उपयोगकर्ता पूर्ववत क्लिक करता है
4. उपयोगकर्ता कुंजी दबाता है
5. उपयोगकर्ता प्रकार एक कुंजी (प्रत्येक परिवर्तन पर सहेजें)

अद्यतन लागू करें

मैं सुझाव दूंगा कि दस्तावेज़ को UPDATEआदेशों की एक श्रृंखला के साथ फिर से बनाने में सक्षम किया जाए ताकि सर्वर प्रत्येक UPDATE को संग्रहीत करे और जब कोई नया ग्राहक जुड़ता है तो उसे अद्यतनों की श्रृंखला भेजी जा सके और यह स्वयं दस्तावेज़ को फिर से प्रदर्शित करने के लिए बना सके। उपभोक्ता। इसके अलावा, आप वैकल्पिक रूप से एक SAVEकमांड रख सकते हैं जो अलग है और इसमें अस्थायी परिवर्तन हो सकते हैं जिनका उपयोग UNDOअनुरोधों के लिए किया जा सकता है और वास्तव में स्टोर करने के लिए इसे स्टोर कर सकते हैं यदि सर्वर बंद है या सभी क्लाइंट डिस्कनेक्ट हो जाते हैं।

Comments

संघर्ष समाधान के बारे में क्या? क्या होगा अगर दो लोग एक ही समय में एक ही क्षेत्र के पाठ को संपादित करें? इसके अलावा, यह डीबी पर एक लोड लगाने के लिए लगता है, जो कुछ ऐसा है जिसे ओपी बचने के लिए देख रहा था। यह उसके लिए व्यवहार्य हो सकता है कि उसे क्या चाहिए।

— सितंबर को

@ पहले मैंने इस मॉडल का उपयोग करके एक स्प्रेडशीट बनाई, और संघर्षों के लिए प्रत्येक विशिष्ट कार्य को अद्यतन किया गया जिसे पूरी तरह से नवीनतम संस्करण द्वारा प्रतिस्थापित किया गया था। तो एक सेल का संपादन खत्म करने वाला अंतिम व्यक्ति पहले से अपडेट किए गए को पूरी तरह से बिना किसी विलय के बदल देगा।

— कोरी हिंटन

एक वाक्य एक दूसरे को अधिलेखित कर देगा यदि यह थे, कहते हैं, एक शब्द दस्तावेज़?

— Ampt

@ हां, वैकल्पिक रूप से, आप जो काम किया जा रहा है, उसे लॉक करने का एक तरीका लागू कर सकते हैं, लेकिन मैंने आसान रास्ता अपनाया।

— कोरी हिंटन

Answer 3

1) नॉकआउट। जेएस पर एक नज़र है

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

2) मिक्स करें कि सिग्नलआर के साथ और अब आपके पास दस्तावेज़ पर काम करने वाले अन्य उपयोगकर्ताओं को सूचनाएं भेजने की क्षमता होनी चाहिए। उनकी साइट से:

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

इसलिए जब भी कोई परिवर्तन होता है, तो आपको कुछ सिग्नलआर कॉल करने के लिए नॉकआउट.जेएस के भीतर अपने मॉडल स्तर पर कुछ हुक करने की आवश्यकता होगी। अन्य क्लाइंट सिग्नलआर से नोटिस प्राप्त करेंगे और फिर मॉडल की अपनी प्रति में एक समान परिवर्तन को ट्रिगर करेंगे, जो कि उनके दृश्य पर वापस धक्का देगा।

यह दो रूपरेखाओं का एक दिलचस्प संयोजन है, और आपको विवरणों को संभालने के लिए अधिक जानकारी खोजने और इकट्ठा करने में सक्षम होना चाहिए।

उदाहरण के लिए, यह कोडप्रोजेक्ट उदाहरण विशेष रूप Co Working UIs and Continuous Clientsसे उन पतों का है, जो आपको लगता है कि आप क्या करने की कोशिश कर रहे हैं।

नए युग के वेब एप्लिकेशन को नए युग के उपयोगकर्ता अनुभव प्रदान करने की आवश्यकता हो सकती है - और सह-कार्यशील और निरंतर क्लाइंट परिदृश्यों को ठीक से संभालना चाहिए। इसमें यह सुनिश्चित करना शामिल है कि उपयोगकर्ता इंटरफ़ेस उपकरणों के पार और उपयोगकर्ताओं के बीच ठीक से समन्वयित हो रहा है ताकि यह सुनिश्चित किया जा सके कि एप्लिकेशन और उपयोगकर्ता इंटरफ़ेस "जैसा है" है।

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

यह ब्लॉग पोस्ट थोड़ा अधिक बुनियादी प्रतीत होता है और दो पैकेजों के संयोजन के लिए आधार प्रदान करता है।

प्रकटीकरण: मैं उपरोक्त किसी भी लिंक से संबद्ध नहीं हूं, न ही मैंने वास्तव में उनकी सामग्री में यह देखने के लिए खोदा है कि यह कितना सही है या सही है।

Answer 4

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

लेकिन ओटी को लागू करना एक मुश्किल काम और समय लेने वाला है। इसलिए आप http://sharejs.org/ जैसी बाहरी लाइब्रेरी का उपयोग करना चाह सकते हैं ।

Comments

Google रीयलटाइम एपीआई OT youtu.be/hv14PTbkIs0?t=14m20s कर रहा है। वे इसे क्लाइंट और सर्वर दोनों पर करते हैं। ShareJS डॉक्स पढ़ने से मुझे स्पष्ट उत्तर नहीं मिल सका लेकिन मैं यह मान रहा हूं कि ShareJS क्लाइंट और सर्वर दोनों पर OT करता है?

— dev.e.loper

Answer 5

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

हालांकि, मैं:

1. सभी क्लाइंट को सर्वर में हर बार एक बार बिना सहेजे परिवर्तन भेजने दें (यह निर्भर करता है कि उपयोगकर्ता दस्तावेजों के साथ कैसे काम करते हैं)।
2. सर्वर उपयोगकर्ता के सत्र में डेल्टास को संग्रहीत करता है (यहां तक ​​कि एक मोटे ग्राहक के लिए आपको सत्र की तरह कुछ चाहिए)
3. उसी दस्तावेज़ को संपादित / देखने वाले अन्य ग्राहकों को वे अस्थायी परिवर्तन या कम से कम एक संकेत मिलता है कि ऐसा हो सकता है।

लाभ:

• जब तक कोई व्यक्ति 'सेव' पर क्लिक नहीं करता तब तक कोई DB अपडेट नहीं
• ग्राहक के क्रैश होने की स्थिति के लिए बैकअप (सत्र-अवधि के लिए)
• आपका सर्वर यह तय करता है कि किस क्लाइंट को कैसे और किस डेटा को फॉरवर्ड करना है (उदाहरण के लिए आप केवल नोट के साथ फीचर शुरू कर सकते हैं और बाद में अधिक परिष्कृत मर्ज और हाइलाइट लागू कर सकते हैं)

नुकसान:

• 'वास्तविक-समय' नहीं - उदाहरण के लिए, आप प्रत्येक 30 सेकंड भेजते हैं, लेकिन कोई व्यक्ति उस समय में 3 वाक्य लिखता है।
• अधिक नेटवर्क ट्रैफ़िक - आपके दस्तावेज़ों और सहयोग पर निर्भर करता है
• संभवतः बड़े सत्र
• संभवत: उच्च कम्प्यूटेशन प्रयास यदि कई उपयोगकर्ता सहयोग करते हैं और कई बदलाव करते हैं

Answer 6

अनिवार्य रूप से, आप जो पूछ रहे हैं वह साझा उत्परिवर्तनीय स्थिति से कैसे निपटना है। बचत करना आसान हिस्सा है; लेकिन आप एक ही समय में एक ही चीज़ को संपादित करने वाले कई लोगों से कैसे निपटते हैं? आप चाहते हैं कि सभी उपयोगकर्ता एक साथ दस्तावेज़ को एक साथ देख रहे हों, साथ ही साथ सभी संपादन वास्तविक समय में हो।

जैसा कि आप शायद एकत्र हुए हैं, यह एक कठिन समस्या है! कुछ व्यावहारिक उपाय हैं:

1. सही एक साथ संपादन की अनुमति नहीं देने के लिए अपनी एप्लिकेशन आवश्यकताओं को संशोधित करें। प्रत्येक ग्राहक के लिए प्रसारित परिणामों के साथ संपादन को स्रोत नियंत्रण प्रणालियों के साथ मिलाया जा सकता है। आप इसे स्वयं बना सकते हैं, लेकिन यह एक उपयोगकर्ता का खराब अनुभव होगा।
2. राज्य म्यूटेशन के सिंक्रनाइज़ेशन को एक ओपन-सोर्स समाधान के लिए आउटसोर्स करता है जो आपकी मौजूदा तकनीक के साथ एकीकृत होता है। ShareDB इस स्थान का वर्तमान नेता है। यह परिचालनात्मक परिवर्तन पर आधारित है और कम से कम एक उत्पादन प्रणाली में उपयोग किया जाता है। यह आपके द्वारा संबंधित बचत मुद्दे का ध्यान रखेगा, लेकिन किसी भी सहयोगी एप्लिकेशन के लिए अनिवार्य अतिरिक्त UX सुविधाओं में से किसी के साथ मदद नहीं करेगा ।
3. एक ऑफ-द-शेल्फ प्लेटफॉर्म का उपयोग करें जैसे कि कन्वर्जेंस (अस्वीकरण: मैं एक संस्थापक हूं) आपके लिए सभी कठिन बिट्स को संभालने के लिए। आपको वास्तविक समय के सहयोग के लिए अतिरिक्त उपकरण भी मिलेंगे जैसे कि कर्सर / माउस ट्रैकिंग, चयन और जल्दी से एक बेहतर सहयोगी अनुभव बनाने के लिए चैट करें। इस प्रश्न को सभी मौजूदा टूल के अच्छे राउंडअप के लिए देखें ।