में असीमित प्रोग्रामिंग मुझे ट्विस्ट में एक रिवर्स प्रॉक्सी विकसित करने में समस्या हो रही है। यह काम करता है, लेकिन यह अत्यधिक जटिल और दृढ़ लगता है। ऐसा लगता है कि वूडू की तरह लगता है।पाइथन ट्विस्टेड
क्या कोई सरल, ठोस वेब पर या पुस्तकों में असीमित प्रोग्राम संरचना के उदाहरण हैं? एक तरह का सर्वोत्तम अभ्यास गाइड? जब मैं अपना प्रोग्राम पूरा करता हूं तो मैं कुछ भी तरीके से संरचना को देखने में सक्षम होना चाहता हूं, स्पेगेटी के कटोरे को नहीं देख रहा हूं।
यदि आप मुड़ने का उपयोग नहीं कर रहे हैं तो एक बहुत अच्छी मार्गदर्शिका थी जिसे मैंने थोड़ी देर पहले इस्तेमाल किया था। यहां link to it है।
ट्विस्ट में large number of examples शामिल है। विशेष रूप से, "evolution of Finger" tutorial में, इस तरह की एक संपूर्ण व्याख्या है कि कैसे एक असीमित प्रोग्राम एक बहुत ही छोटे कर्नेल से जटिल प्रणाली तक बढ़ता है जिसमें बहुत से चलने वाले भाग होते हैं। एक और जो आपके लिए रूचि रख सकता है वह केवल writing servers के बारे में ट्यूटोरियल है।
मुड़ या अन्य अतुल्यकालिक नेटवर्किंग पुस्तकालयों (जैसे asyncore, MINA, या ACE) के बारे में ध्यान में रखने की कुंजी बात, अपने कोड केवल लागू हो जाता है कि जब कुछ होता है। जिस हिस्से को मैंने अक्सर सुना है वह "वूडू" जैसा लगता है, कॉलबैक का प्रबंधन है: उदाहरण के लिए, Deferred। यदि आप सीधे कोड में चलने वाले कोड को लिखने के लिए उपयोग किए जाते हैं, और केवल उन कार्यों को कॉल करते हैं जो परिणामों के साथ तुरंत लौटते हैं, तो आपको वापस कॉल करने के लिए कुछ इंतजार करने का विचार भ्रमित हो सकता है। लेकिन कॉलबैक के बारे में कोई जादूई नहीं, कोई "वूडू" नहीं है। निम्नतम स्तर पर, रिएक्टर बस के चारों ओर बैठे और चीजों की एक छोटी संख्या में से एक होने के लिए इंतज़ार कर रहा है:
dataReceived कॉल करेंगे)callLater के साथ पंजीकृत एक समारोह को कॉल करेगा)।buildProtocol को listenXXX या connectXXX फ़ंक्शन के साथ पंजीकृत कारखाने पर कॉल करेगा)।connectionLost कॉल करेंगे) निकाल दिया गयाहर अतुल्यकालिक कार्यक्रम इन घटनाओं में से कुछ ऊपर hooking और फिर उन्हें क्या होने के लिए प्रतीक्षा करने रिएक्टर बंद लात से शुरू होता है हो गया है। बेशक, ऐसी घटनाएं होती हैं जो अधिक घटनाओं को जन्म देती हैं जो हुक अप या डिस्कनेक्ट हो जाती हैं, और इसलिए आपका प्रोग्राम अपने मजेदार तरीके से चला जाता है। इसके अलावा, असीमित प्रोग्राम संरचना के बारे में कुछ खास नहीं है जो दिलचस्प या विशेष हैं; ईवेंट हैंडलर और कॉलबैक केवल ऑब्जेक्ट्स हैं, और आपका कोड सामान्य तरीके से चलाया जाता है।
यहां एक साधारण "ईवेंट-संचालित इंजन" है जो आपको दिखाता है कि यह प्रक्रिया कितनी सरल है।
# Engine
import time
class SimplestReactor(object):
def __init__(self):
self.events = []
self.stopped = False
def do(self, something):
self.events.append(something)
def run(self):
while not self.stopped:
time.sleep(0.1)
if self.events:
thisTurn = self.events.pop(0)
thisTurn()
def stop(self):
self.stopped = True
reactor = SimplestReactor()
# Application
def thing1():
print 'Doing thing 1'
reactor.do(thing2)
reactor.do(thing3)
def thing2():
print 'Doing thing 2'
def thing3():
print 'Doing thing 3: and stopping'
reactor.stop()
reactor.do(thing1)
print 'Running'
reactor.run()
print 'Done!'
मुड़ तरह पुस्तकालयों के मूल में, मुख्य पाश में समारोह sleep नहीं है, लेकिन select() या poll() की तरह एक ऑपरेटिंग सिस्टम कॉल, के रूप में the Python select module की तरह एक मॉड्यूल द्वारा उजागर। मैं कहता हूं "0", क्योंकि यह एक एपीआई है जो प्लेटफार्मों के बीच बहुत भिन्न होता है, और लगभग हर जीयूआई टूलकिट का अपना संस्करण होता है। ट्विस्ट वर्तमान में इस विषय पर 14 विभिन्न भिन्नताओं के लिए एक अमूर्त इंटरफ़ेस प्रदान करता है। आम बात यह है कि ऐसा एपीआई प्रदान करता है, यह कहने का एक तरीका प्रदान करता है कि "यहां उन घटनाओं की एक सूची दी गई है जिनकी मैं प्रतीक्षा कर रहा हूं। उनमें से एक तब तक सो जाओ, तब उठो और मुझे बताओ कि उनमें से कौन सा था।"
मुझे आशा है कि आपको मुड़ने के साथ बेहतर भाग्य हो रहा है। यह वर्तमान में मेरे पसंदीदा ढांचे में से एक है। – Dustin