उल्का डॉक्स में संदेश-गणना उदाहरण कैसे काम करता है?

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

Meteor.publish काफी लचीला है। यह क्लाइंट को मौजूदा MongoDB संग्रह प्रकाशित करने तक सीमित नहीं है:हम जो चाहें प्रकाशित कर सकते हैं। विशेष रूप से, Meteor.publish दस्तावेजों के सेट . को परिभाषित करता है जिसे ग्राहक सब्सक्राइब कर सकता है। प्रत्येक दस्तावेज़ कुछ संग्रह नाम (एक स्ट्रिंग) से संबंधित है, एक अद्वितीय _id . है फ़ील्ड, और उसके बाद JSON विशेषताओं का कुछ सेट है। जैसे ही सेट में दस्तावेज़ बदलते हैं, सर्वर क्लाइंट को अद्यतित रखते हुए, प्रत्येक सब्सक्राइब किए गए क्लाइंट को परिवर्तन भेज देगा।

हम यहां सेट किए गए एक दस्तावेज़ को परिभाषित करने जा रहे हैं, जिसे "counts-by-room" . कहा जाता है , जिसमें "counts" . नामक संग्रह में एक ही दस्तावेज़ है . दस्तावेज़ में दो फ़ील्ड होंगे:एक roomId एक कमरे की आईडी के साथ, और count :उस कमरे में संदेशों की कुल संख्या। कोई वास्तविक MongoDB संग्रह नहीं है जिसका नाम counts है . यह केवल उस संग्रह का नाम है जिसे हमारा उल्का सर्वर क्लाइंट को नीचे भेजेगा, और एक क्लाइंट-साइड में संग्रहीत करेगा। count named नाम का संग्रह ।

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

जब हम पहली बार observeChanges . को कॉल करते हैं , कुछ संख्या में added कॉलबैक तुरंत चलेंगे, प्रत्येक संदेश के लिए जो पहले से मौजूद है। फिर जब भी संदेश जोड़े या निकाले जाएंगे तो भविष्य में होने वाले परिवर्तन सक्रिय होंगे।

हमारा पब्लिश फंक्शन एक onStop . भी रजिस्टर करता है जब क्लाइंट सदस्यता समाप्त करता है (या तो मैन्युअल रूप से, या डिस्कनेक्ट होने पर) सफाई करने के लिए हैंडलर। यह हैंडलर क्लाइंट से विशेषताओं को हटा देता है और चल रहे observeChanges . को तोड़ देता है ।

जब भी कोई नया क्लाइंट "counts-by-room" को सब्सक्राइब करता है, तो हर बार एक पब्लिश फंक्शन चलता है। , इसलिए प्रत्येक क्लाइंट के पास एक observeChanges . होगा उसकी ओर से चल रहा है।

// server: publish the current size of a collection
Meteor.publish("counts-by-room", function (roomId) {
  var self = this;
  var count = 0;
  var initializing = true;

  var handle = Messages.find({room_id: roomId}).observeChanges({
    added: function (doc, idx) {
      count++;
      if (!initializing)
        self.changed("counts", roomId, {count: count});  // "counts" is the published collection name
    },
    removed: function (doc, idx) {
      count--;
      self.changed("counts", roomId, {count: count});  // same published collection, "counts"
    }
    // don't care about moved or changed
  });

  initializing = false;

  // publish the initial count. `observeChanges` guaranteed not to return
  // until the initial set of `added` callbacks have run, so the `count`
  // variable is up to date.
  self.added("counts", roomId, {count: count});

  // and signal that the initial document set is now available on the client
  self.ready();

  // turn off observe when client unsubscribes
  self.onStop(function () {
    handle.stop();
  });
});

अब, क्लाइंट पर, हम इसे सामान्य उल्का सदस्यता की तरह ही मान सकते हैं। सबसे पहले, हमें एक Mongo.Collection . चाहिए जो हमारे परिकलित गणना दस्तावेज़ को धारण करेगा। चूंकि सर्वर "counts" . नामक संग्रह में प्रकाशित हो रहा है , हम "counts" . पास करते हैं Mongo.Collection . के तर्क के रूप में कंस्ट्रक्टर।

// client: declare collection to hold count object
Counts = new Mongo.Collection("counts");

तब हम सदस्यता ले सकते हैं। (आप संग्रह घोषित करने से पहले वास्तव में सदस्यता ले सकते हैं:उल्का आने वाले अपडेट को तब तक कतारबद्ध करेगा जब तक कि उन्हें रखने के लिए कोई जगह न हो।) सदस्यता का नाम "counts-by-room" . है , और यह एक तर्क लेता है:वर्तमान कमरे की आईडी। मैंने इसे Deps.autorun . के अंदर लपेटा है ताकि Session.get('roomId') . के रूप में परिवर्तन, क्लाइंट स्वचालित रूप से पुराने कमरे की संख्या से सदस्यता समाप्त कर देगा और नए कमरे की संख्या के लिए फिर से सदस्यता लेगा।

// client: autosubscribe to the count for the current room
Tracker.autorun(function () {
  Meteor.subscribe("counts-by-room", Session.get("roomId"));
});

अंत में, हमें दस्तावेज़ counts . में मिल गया है और हम इसे क्लाइंट पर किसी भी अन्य Mongo संग्रह की तरह ही उपयोग कर सकते हैं। कोई भी टेम्प्लेट जो इस डेटा को संदर्भित करता है, जब भी सर्वर एक नई गणना भेजता है, तो वह स्वचालित रूप से फिर से तैयार हो जाएगा।

// client: use the new collection
console.log("Current room has " + Counts.findOne().count + " messages.");