आप पाइथन सॉकेट कैसे फ्लश करते हैं?

Question

मैंने पाइथन में एक सर्वर लिखा है जिसका अर्थ है क्लाइंट को डेटा "हेडर: संदेश"

मैं प्रत्येक संदेश को अलग-अलग भेजना चाहता हूं ताकि ग्राहक को आवश्यकता हो "हेडर" और "संदेश" पढ़ने के लिए न्यूनतम कार्य करें

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

उदाहरण:

सर्वर भेजता है ...

socket.send ("header1:message1") 
socket.send ("header2:message2") 
socket.send ("header3:message3") 

ग्राहक प्राप्त करता है ... "header1: message1header2: message2header3: message3"

मैं तीन अलग-अलग संदेश प्राप्त करना चाहते हैं

header1:message1 
header2:message2 
header3:message3 

मुझे ईएसी के बाद फ्लश करने का एक तरीका चाहिए एच

Answer 1

मुझे लगता है कि आप एक टीसीपी कनेक्शन पर बात कर रहे हैं।

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

यदि आपको वास्तव में डेटाग्राम आधारित सेवाओं की आवश्यकता है तो यूडीपी पर स्विच करें। आपको उस मामले में खुद को पुनः प्रेषण को संभालने की आवश्यकता होगी।

स्पष्ट करने के लिए:

भेजने बफर निस्तब्धता आमतौर पर नए संकुल बनाता है, जैसा कि आप उम्मीद बस के रूप में। यदि आपका ग्राहक इन पैकेजों को तेज़ी से पढ़ता है तो आपको प्रति पढ़ने के लिए एक संदेश मिल सकता है।

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

Answer 2

आप जो करने का प्रयास कर रहे हैं, वह आपके डेटा को "बैचों" में विभाजित कर रहा है।

उदाहरण के लिए, जब भी आप फ़ाइल से "लाइनें" पढ़ते हैं तो आप "बैच" पर काम कर रहे हैं। क्या एक "रेखा" परिभाषित करता है? यह '\ n' द्वारा समाप्त बाइट्स का अनुक्रम है। एक और उदाहरण है: आप फ़ाइल से 64KiB "भाग" पढ़ते हैं। क्या एक "खंड" परिभाषित करता है? आप करते हैं, क्योंकि आप हर बार 65536 बाइट पढ़ते हैं। आप एक परिवर्तनीय लंबाई "खंड" चाहते हैं? आप बस अपने आकार के साथ अपने "खंड" को उपसर्ग करते हैं, फिर "खंड" पढ़ें। "एआईएफ" फाइलें (जिनका कार्यान्वयन एमएस विंडोज़ की .wav और .avi फाइलें भी हैं) और "mov" फाइलें इस तरह व्यवस्थित होती हैं।

1. रिकॉर्ड विभाजक
2. तय आकार रिकॉर्ड
3. रिकॉर्ड उनके आकार के साथ उपसर्ग:

   इन तीन तरीकों सबसे बुनियादी तरीकों बाइट्स की एक धारा जो कुछ मध्यम व्यवस्थित करने के लिए, कर रहे हैं।

उन्हें मिश्रित और/या संशोधित किया जा सकता है। उदाहरण के लिए, आपके पास एक एक्सएमएल रीडर की तरह "वेरिएबल रिकॉर्ड सेपरेटर्स" हो सकते हैं: पहले '012' तक पहले '<' से बाइट पढ़ें, पहले '<' के बाद स्लैश जोड़ें और इसे अंत तक रिकॉर्ड करें, स्ट्रीम तक स्ट्रीम करें अंत के- रिकॉर्ड। यह सिर्फ एक कच्चा वर्णन है।

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

Answer 3

सिर्फ संलग्न \ N हर संदेश ...

तरह

socket.send के बाद ("header1: message1 \ n")

socket.send ("header2: message2 \ n")

socket.send ("header3: message3 \ n")