🤦🏿 👦🏿 🤸🏼 Push + ActiveMQ - ZendFramework = ... या एक ड्राइव प्रोजेक्ट का इतिहास 👩🏻‍🏫 🆚 🔮

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

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

चेतावनी! यह shnyaga आपके सर्वर को मार सकता है! वैसे, अगर आप अचानक एक अत्यधिक भरी हुई स्कैंडिनेवियाई नीलामी को लिखने का फैसला करते हैं - सच्चाई और मजाकिया चित्र कहीं न कहीं, कट के नीचे हैं।

PUSH के बारे में कुछ शब्द

PUSH तकनीक का उपयोग करना उचित है जहां आपको सर्वर साइड पर कुछ परिवर्तनों के साथ बहुत जल्दी ग्राहकों को अपडेट करने की आवश्यकता होती है। सामान्य तौर पर, क्लाइंट-सर्वर संचार ऐसा दिखता है

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

कार्य प्रक्रिया

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

कहने की जरूरत नहीं है, एक ही समय में काफी अपडेट अनुरोध प्राप्त किए जा सकते हैं। ऐसा करने के लिए, ऐसे आयोजनों की एक कतार आयोजित की जानी चाहिए, जहाँ से धूमकेतु घटनाओं को ले जा सकेंगे और उन्हें आगे भेज सकेंगे।

ऐसा तब होता है जब हमने चैट में कुछ लिखा है।

इस योजना में दो मुख्य बिंदु हैं:

धूमकेतु का कार्यान्वयन ( बाल्पीक एक अच्छा अवलोकन प्रदान करता है)
कतार कार्यान्वयन। आइए उन पर अधिक विस्तार से ध्यान दें।

कतार कार्यान्वयन

हमारे प्रोजेक्ट के लिए यह आवश्यक था कि:

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

दो प्रक्रियाओं के बीच बातचीत के सरल मामलों में, आप PHP में निर्मित कतारों के साथ काम करने के लिए कार्यों का उपयोग कर सकते हैं, या Zend_Queen रैपर। हालांकि, वे सभी सुनने की प्रक्रियाओं (धूमकेतु) को तुरंत घटना प्रदान नहीं करते हैं।

कतारों के साथ प्रयोग

एक संभावित समाधान एक कतार प्रबंधक है ।
कार्यान्वयन विधि:

प्रत्येक धूमकेतु अपनी बारी उठाता है।
नई कतार के पहचानकर्ता को सभी प्रक्रियाओं के लिए साझा मेमोरी में दर्ज किया जाता है।
कतारों के साथ कई प्रक्रियाओं के एक साथ संचालन को रोकने के लिए, एक सेमाफोर का उपयोग किया जाता है।
कतार में एक संदेश भेजते समय, घटना को प्रत्येक प्रक्रिया की कतार में भेजा जाता है।

कुछ इस तरह:

// जब हमने इस तस्वीर को कागज के एक टुकड़े पर खींचा - हम पहले से ही डर गए थे, लेकिन एक बहादुर साइकिल चालक कार्यान्वयन को खत्म करने की कोशिश कर सकता है।

यहां तक कि अगर हम ऐसा प्रबंधक बनाते हैं, तो धूमकेतु केवल तभी जागेंगे जब नई घटनाएं आएंगी , और यह स्पष्ट रूप से हमारे लिए पर्याप्त नहीं है (यह जानने की आवश्यकता याद रखें कि अब कौन जीवित है?)।

दुर्भाग्य से, मानक php फ़ंक्शंस का उपयोग करके टाइमआउट के साथ कतारबद्ध करना संभव नहीं है। यह मुझे किसी प्रकार की थर्ड-पार्टी सर्वर प्रक्रिया को लागू करने के लिए हुआ, जो समय-समय पर धूमकेतु, घटनाओं को "कतार में" जगाती है। वैसे, एक ही प्रक्रिया साझा मेमोरी से मृत कतार पहचानकर्ताओं को भी हटा सकती है। यहाँ परिणाम है:

जब इस तस्वीर को देख अनजाने में लुगोवस्की के बयान को याद करते हैं

"मूढ़ और हास्यास्पद वास्तुशिल्प पर मानवीय कल्पना असीम है ..."

हम अपने आवेदन में प्रयोज्य के संदर्भ में कतारबद्ध करने के लिए मौजूदा समाधानों का विश्लेषण करना शुरू करते हैं।

हमारी पसंद अपाचे ActiveMQ पर गिर गई (हमने वास्तव में इसे और रैबिटएमक्यू के बीच चुना)
पेशेवरों:

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

माइनस : कतार में संदेशों की संख्या वापस नहीं कर सकते

Aleks_raiden habrayuzer से कतार प्रबंधकों का अधिक विस्तृत अवलोकन यहां पाया जा सकता है
http://habrahabr.ru/blogs/hi/44907/
http://habrahabr.ru/blogs/hi/45891/

केवल एक चीज जो सीधे विषय तंत्र का उपयोग करके लागू नहीं की जा सकती थी, यह उन घटनाओं की वसूली थी जो तब हो सकती है जब धूमकेतु का कनेक्शन गुलाब से पहले टूट गया था (यह विषय तंत्र को छोड़कर और प्रत्येक प्रक्रिया के लिए व्यक्तिगत कतारों का उपयोग करके किया जा सकता है, लेकिन ...)

हमने ताजा एन घटनाओं को साझा स्मृति में रखने का फैसला किया ताकि धूमकेतु तुरंत अपने संदर्भ को बहाल कर सके। परिणामस्वरूप, वास्तुकला इस प्रकार है:

Brenchmarki

आवेदन को लागू करने के लिए, हमने ZendFramework का उपयोग किया। Ajax अनुरोधों को संबंधित नियंत्रकों को भेजा गया था, जिन्होंने उन्हें संसाधित किया और संदेशों को एक कतार में रखा, जहां से धूमकेतु ने संदेश ले लिया और उन्हें ग्राहकों को भेजा। ZendFramework कंट्रोलर के अंदर स्वयं धूमकेतु को भी Action के रूप में कार्यान्वित किया जाता है।

Apache Branchmark को शुरू करते हुए, हम यह जानकर भयभीत थे कि सिस्टम सक्रिय रूप से 25 एक साथ एक्सेस के साथ प्रोसेसर खा रहा है।

25 एक साथ सूत्र के लिए 300 अनुरोध

जैसा कि यह निकला, ZendFramework आरंभीकरण और डेटाबेस कनेक्शन ने 99% समय लिया। हे-ऑप्स। खैर, यह पुरानी खबर है, और इसके लिए इलाज ज्ञात है - आपको वास्तव में आवश्यक लोगों को छोड़कर, ZendFramework वर्गों को शामिल करने की आवश्यकता है। और सभी आवश्यक वर्गों को एक फ़ाइल में संयोजित करें।

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

परिणाम

प्रति 100 धागे पर 300 अनुरोध

क्लाइंट से घटनाओं की प्रतिक्रिया लगभग तात्कालिक हो गई है। हुर्रे, जीत! लाइटवेट धूमकेतु मेमोरी का उपयोग करते हैं और प्रोसेसर बहुत किफायती है। आवेदन की संकीर्ण गर्दन वीडियो स्ट्रीम का वितरण है (लेकिन यदि आप एक स्कैंडिनेवियाई नीलामी करते हैं, जहां एक समान कतारबद्ध वास्तुकला को प्रभावी ढंग से लागू करना संभव है - यह आपकी समस्या नहीं है ;-), हम इस लेख के बारे में निम्नलिखित लेखों में लिख सकते हैं यदि हम हबल प्रभाव का सामना कर सकते हैं।

नीचे हमारा कतार प्रबंधक है।

<?php require_once 'Zend/Queue.php'; require_once 'Sibirix/Queue/Smemory/Package.php'; /** *   * */ class Sibirix_Queue_Smemory_Manager { const ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE = "BROKEN_OPTIONS_FOR_INIT"; const ERROR_UNKNOWN_IDENTIFIER_STORAGE_MESSAGE = "UNKNOWN_IDENTIFIER_STORAGE"; const ERROR_CAN_NOT_ACTIVATE_THE_SEMAPHORE_MESSAGE = "CAN_NOT_ACTIVATE_THE_SEMAPHORE"; const SHM_VAR_LAST_CHAT_POSTS = 1; const SHM_VAR_LAST_SYSTEM_COMMAND = 2; const SHM_VAR_QUEUE_LAST_ID = 3; private $_count_chat_package_storage; private $_count_system_package_storage; private $_activeMQoptions; private $_queue; /** * semaphore key */ private $_sem_key; /** * Shared memory APP_KEY = one symbol */ private $_app_key; private $_shared_memory_id = false; private $_shared_memory_handler = false; private $_shared_memory_size; private $_sem_id = false; private $_last_queue_message_id = false; public function __construct($options = array()) { if (!is_array($options)) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } if (!isset($options['sem_key'])) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } if (!isset($options['app_key'])) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } else { $options['app_key'] = (string)$options['app_key']; if (strlen($options['app_key']) != 1) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } } if (!isset($options['activeMQ'])) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } if (!isset($options['shared_memory_size'])) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } if (!isset($options['count_chat_package_storage'])) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } if (!isset($options['count_system_package_storage'])) { throw new Exception(self::ERROR_BROKEN_OPTIONS_FOR_INIT_MESSAGE); } $this->_sem_key = $options['sem_key']; $this->_app_key = $options['app_key']; $this->_activeMQoptions = $options['activeMQ']; $this->_shared_memory_size = $options['shared_memory_size']; $this->_count_chat_package_storage = $options['count_chat_package_storage']; $this->_count_system_package_storage = $options['count_system_package_storage']; $this->_sem_id = sem_get($this->_sem_key, 1); $this->_shared_memory_id = ftok(".", $this->_app_key); $this->_shared_memory_handler = shm_attach($this->_shared_memory_id, $this->_shared_memory_size); } public function connectTopic() { if (!$this->_queue) { $this->_queue = new Zend_Queue('Activemq', $this->_activeMQoptions); } return $this->_queue; } public function receive() { $this->connectTopic(); $message = false; $msg_receive = $this->_queue->receive(1); foreach ( $msg_receive as $msg ) { $pkg = new Sibirix_Queue_Smemory_Package($msg->body); $this->_last_queue_message_id = $pkg->id; $message = $pkg; } return $message; } public function receiveAll() { $this->connectTopic(); $last_queue_message_id_mem = $this->_sem_getLastQueueMessageId(); $messages = array(); while(true) { $msg_receive = $this->_queue->receive(1); if (!$msg_receive->count()) {break;} foreach ( $msg_receive as $message ) { $pkg = new Sibirix_Queue_Smemory_Package($message->body); $this->_last_queue_message_id = $pkg->id; $messages[] = $pkg; } if ($this->_last_queue_message_id >= $last_queue_message_id_mem ) { $last_queue_message_id_mem = $this->_sem_getLastQueueMessageId(); if ($this->_last_queue_message_id >= $last_queue_message_id_mem ) { break; } } } return $messages; } public function send($action, $data, $recipient = false) { $this->connectTopic(); $package = new Sibirix_Queue_Smemory_Package($action, $data, $recipient); $this->_lock(); $last_queue_message_id_mem = $this->_getLastQueueMessageId(); $last_queue_message_id_mem++; $this->_setLastQueueMessageId($last_queue_message_id_mem); $this->_queue->send( $package->normalize( $last_queue_message_id_mem ) ); if ( $package->isPost() ) { $this->_savePackageToChatStorage( $package ); } else { $this->_savePackageToSystemStorage( $package ); } $this->_unlock(); return $last_queue_message_id_mem; } private function _getLastQueueMessageId() { $last_queue_message_id_mem = shm_get_var($this->_shared_memory_handler, self::SHM_VAR_QUEUE_LAST_ID); if (!$last_queue_message_id_mem) { shm_put_var($this->_shared_memory_handler, self::SHM_VAR_QUEUE_LAST_ID, 0); $last_queue_message_id_mem = 0; } return $last_queue_message_id_mem; } private function _setLastQueueMessageId($id) { shm_put_var($this->_shared_memory_handler, self::SHM_VAR_QUEUE_LAST_ID, $id); return true; } private function _sem_getLastQueueMessageId() { $this->_lock(); $last_queue_message_id_mem = $this->_getLastQueueMessageId(); $this->_unlock(); return $last_queue_message_id_mem; } private function _savePackageToChatStorage( $package ) { $last_chat_posts = shm_get_var($this->_shared_memory_handler, self::SHM_VAR_LAST_CHAT_POSTS); if (!$last_chat_posts) {$last_chat_posts=array();} if (count($last_chat_posts) >= $this->_count_chat_package_storage) { while(count($last_chat_posts) >= $this->_count_chat_package_storage) { array_shift($last_chat_posts); } } array_push($last_chat_posts, $package->normalize()); shm_put_var($this->_shared_memory_handler, self::SHM_VAR_LAST_CHAT_POSTS, $last_chat_posts); } private function _savePackageToSystemStorage($package) { $last_sys_cmd = shm_get_var($this->_shared_memory_handler, self::SHM_VAR_LAST_SYSTEM_COMMAND); if (!$last_sys_cmd) {$last_sys_cmd=array();} if (count($last_sys_cmd) >= $this->_count_system_package_storage) { while(count($last_sys_cmd) >= $this->_count_system_package_storage) { array_shift($last_sys_cmd); } } array_push($last_sys_cmd, $package->normalize()); shm_put_var($this->_shared_memory_handler, self::SHM_VAR_LAST_SYSTEM_COMMAND, $last_sys_cmd); } public function getLastPackage($storage) { if ( $storage != self::SHM_VAR_LAST_SYSTEM_COMMAND && $storage != self::SHM_VAR_LAST_CHAT_POSTS ) { throw new Exception(self::ERROR_UNKNOWN_IDENTIFIER_STORAGE_MESSAGE); } $this->_lock(); $last_packages = shm_get_var($this->_shared_memory_handler, $storage); if (!$last_packages) {$last_packages=array();} $this->_unlock(); $return_last_packages = array(); foreach($last_packages as $normalize_package) { $package = new Sibirix_Queue_Smemory_Package($normalize_package); $return_last_packages[] = $package; } return $return_last_packages; } private function _lock() { if (!sem_acquire($this->_sem_id)) { throw new Exception(self::ERROR_CAN_NOT_ACTIVATE_THE_SEMAPHORE_MESSAGE); } } private function _unlock() { sem_release($this->_sem_id); } public function resetMemory() { $this->_lock(); shm_put_var($this->_shared_memory_handler, self::SHM_VAR_LAST_CHAT_POSTS, array()); shm_put_var($this->_shared_memory_handler, self::SHM_VAR_LAST_SYSTEM_COMMAND, array()); $this->_setLastQueueMessageId(0); $this->_lock(); } public function getLastQueueMessageId() { $this->_lock(); $last_queue_message_id_mem = $this->_getLastQueueMessageId(); $this->_unlock(); return $last_queue_message_id_mem; } } ?>

 <?php /** *    * */ class Sibirix_Queue_Smemory_Package { const ERROR_NOT_SUPPORTED_TYPE_ACTION_MESSAGE = 'ERROR_NOT_SUPPORTED_TYPE_ACTION'; const ERROR_FOR_NORMALIZE_NEED_ID_MESSAGE = 'FOR_NORMALIZE_NEED_ID'; const CHAT_ACTION = 'pasteChatMessages'; private $_supported_actions = array( 'updateRating', 'setChannel', 'pasteChatMessages', 'updateTimer', 'connectToServer', 'statistics' ); private $_read_private_property = array( 'id','action','time','data','recipient' ); private $_action; private $_data; private $_recipient; private $_time; private $_id; public function __construct() { $fg_args = func_get_args(); if (count($fg_args) == 1) { list( $this->_id, $this->_action, $this->_time, $this->_data, $this->_recipient ) = unserialize($fg_args[0]); } else { list($action, $data, $recipient) = $fg_args; $this->_validation($action, $data, $recipient); $this->_action = $action; $this->_data = $data; $this->_time = $this->_getmicrotime(); $this->_recipient = $recipient; } } public function normalize( $id = false ) { if ($id) { $this->_id = $id; } else { if ($this->_id === null) { throw new Exception(self::ERROR_FOR_NORMALIZE_NEED_ID_MESSAGE); } } return serialize(array( 0 => $this->_id, 1 => $this->_action, 2 => $this->_time, 3 => $this->_data, 4 => $this->_recipient )); } private function _validation($action, $data, $recipient) { if (!in_array($action, $this->_supported_actions)) { throw new Exception(self::ERROR_NOT_SUPPORTED_TYPE_ACTION_MESSAGE); } return true; } private function _getmicrotime() { list($usec, $sec) = explode(' ', microtime()); return number_format(((float)$usec + (float)$sec), 2, '.', ''); } public function __get($key) { if (in_array($key, $this->_read_private_property)) { return $this->{'_'.$key}; } return null; } public function isPost() { if ( $this->_action == self::CHAT_ACTION ) { return true; } return false; } } ?>

निष्कर्ष

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

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

आपका ध्यान देने के लिए धन्यवाद, मुझे सवालों और टिप्पणियों को सुनने में खुशी होगी और उन्हें जवाब देने में खुशी होगी।

युपीडी। पाठकों के अनुरोध पर - मैं परियोजना के लिए एक लिंक प्रकाशित करता हूँ http://feelyoustar.com/

Push + ActiveMQ - ZendFramework = ... या एक ड्राइव प्रोजेक्ट का इतिहास